{"dsyconvf"=>
  {"summary"=>
    ["If parameter WAY = 'C':",
     "DSYCONVF converts the factorization output format used in",
     "DSYTRF provided on entry in parameter A into the factorization",
     "output format used in DSYTRF_RK (or DSYTRF_BK) that is stored",
     "on exit in parameters A and E. It also coverts in place details of",
     "the intechanges stored in IPIV from the format used in DSYTRF into",
     "the format used in DSYTRF_RK (or DSYTRF_BK).",
     "If parameter WAY = 'R':",
     "DSYCONVF performs the conversion in reverse direction, i.e.",
     "converts the factorization output format used in DSYTRF_RK",
     "(or DSYTRF_BK) provided on entry in parametes A and E into",
     "the factorization output format used in DSYTRF that is stored",
     "on exit in parameter A. It also coverts in place details of",
     "the intechanges stored in IPIV from the format used in DSYTRF_RK",
     "(or DSYTRF_BK) into the format used in DSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix A.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         1) If WAY ='C':",
       "         On entry, contains factorization details in format used in",
       "         DSYTRF:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         DSYTRF_RK or DSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         2) If WAY = 'R':",
       "         On entry, contains factorization details in format used in",
       "         DSYTRF_RK or DSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         DSYTRF:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, just a workspace.",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         2) If WAY = 'R':",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not referenced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         On exit, is not changed"],
     "IPIV"=>
      ["[in,out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, details of the interchanges and the block",
       "         structure of D in the format used in DSYTRF.",
       "         On exit, details of the interchanges and the block",
       "         structure of D in the format used in DSYTRF_RK",
       "         ( or DSYTRF_BK).",
       "         1) If WAY ='R':",
       "         On entry, details of the interchanges and the block",
       "         structure of D in the format used in DSYTRF_RK",
       "         ( or DSYTRF_BK).",
       "         On exit, details of the interchanges and the block",
       "         structure of D in the format used in DSYTRF."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cla_hercond_c"=>
  {"summary"=>
    ["   CLA_HERCOND_C computes the infinity norm condition number of",
     "   op(A) * inv(diag(C)) where C is a REAL vector."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by CHETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by CHETRF."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The vector C in the formula op(A) * inv(diag(C))."],
     "CAPPLY"=>
      ["[in]",
       "         CAPPLY is LOGICAL",
       "    If .TRUE. then access the vector C in the formula above."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is REAL array, dimension (N).",
       "    Workspace."]}},
 "cgelqt3"=>
  {"summary"=>
    ["CGELQT3 recursively computes a LQ factorization of a complex M-by-N",
     "matrix A, using the compact WY representation of Q.",
     "Based on the algorithm of Elmroth and Gustavson,",
     "IBM J. Res. Develop. Vol 44 No. 4 July 2000."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M =< N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the real M-by-N matrix A.  On exit, the elements on and",
       "         below the diagonal contain the N-by-N lower triangular matrix L; the",
       "         elements above the diagonal are the rows of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dlasd4"=>
  {"summary"=>
    ["This subroutine computes the square root of the I-th updated",
     "eigenvalue of a positive symmetric rank-one modification to",
     "a positive diagonal matrix whose entries are given as the squares",
     "of the corresponding entries in the array d, and that",
     "       0 <= D(i) < D(j)  for  i < j",
     "and that RHO > 0. This is arranged by the calling routine, and is",
     "no loss in generality.  The rank-one modified system is thus",
     "       diag( D ) * diag( D ) +  RHO * Z * Z_transpose.",
     "where we assume the Euclidean norm of Z is 1.",
     "The method consists of approximating the rational functions in the",
     "secular equation by simpler interpolating rational functions."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "        The length of all arrays."],
     "I"=>
      ["[in]",
       "         I is INTEGER",
       "        The index of the eigenvalue to be computed.  1 <= I <= N."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension ( N )",
       "        The original eigenvalues.  It is assumed that they are in",
       "        order, 0 <= D(I) < D(J)  for I < J."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension ( N )",
       "        The components of the updating vector."],
     "DELTA"=>
      ["[out]",
       "         DELTA is DOUBLE PRECISION array, dimension ( N )",
       "        If N .ne. 1, DELTA contains (D(j) - sigma_I) in its  j-th",
       "        component.  If N = 1, then DELTA(1) = 1.  The vector DELTA",
       "        contains the information necessary to construct the",
       "        (singular) eigenvectors."],
     "RHO"=>
      ["[in]",
       "         RHO is DOUBLE PRECISION",
       "        The scalar in the symmetric updating formula."],
     "SIGMA"=>
      ["[out]",
       "         SIGMA is DOUBLE PRECISION",
       "        The computed sigma_I, the I-th updated eigenvalue."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension ( N )",
       "        If N .ne. 1, WORK contains (D(j) + sigma_I) in its  j-th",
       "        component.  If N = 1, then WORK( 1 ) = 1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit",
       "        > 0:  if INFO = 1, the updating process failed."]}},
 "cgeqr2p"=>
  {"summary"=>
    ["CGEQR2P computes a QR factorization of a complex m by n matrix A:",
     "A = Q * R. The diagonal entries of R are real and nonnegative."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(m,n) by n upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n). The diagonal entries of R are",
       "         real and nonnegative; the elements below the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "cpptrs"=>
  {"summary"=>
    ["CPPTRS solves a system of linear equations A*X = B with a Hermitian",
     "positive definite matrix A in packed storage using the Cholesky",
     "factorization A = U**H*U or A = L*L**H computed by CPPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H, packed columnwise in a linear",
       "         array.  The j-th column of U or L is stored in the array AP",
       "         as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dsyevd_2stage"=>
  {"summary"=>
    ["DSYEVD_2STAGE computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric matrix A using the 2stage technique for",
     "the reduction to tridiagonal. If eigenvectors are desired, it uses a",
     "divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array,",
       "                                        dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + 2*N+1",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + 2*N+1",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least",
       "                                               1 + 6*N + 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i and JOBZ = 'N', then the algorithm failed",
       "               to converge; i off-diagonal elements of an intermediate",
       "               tridiagonal form did not converge to zero;",
       "               if INFO = i and JOBZ = 'V', then the algorithm failed",
       "               to compute an eigenvalue while working on the submatrix",
       "               lying in rows and columns INFO/(N+1) through",
       "               mod(INFO,N+1)."]}},
 "zggbak"=>
  {"summary"=>
    ["ZGGBAK forms the right or left eigenvectors of a complex generalized",
     "eigenvalue problem A*x = lambda*B*x, by backward transformation on",
     "the computed eigenvectors of the balanced pair of matrices output by",
     "ZGGBAL."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the type of backward transformation required:",
       "         = 'N':  do nothing, return immediately;",
       "         = 'P':  do backward transformation for permutation only;",
       "         = 'S':  do backward transformation for scaling only;",
       "         = 'B':  do backward transformations for both permutation and",
       "                 scaling.",
       "         JOB must be the same as the argument JOB supplied to ZGGBAL."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  V contains right eigenvectors;",
       "         = 'L':  V contains left eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrix V.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         The integers ILO and IHI determined by ZGGBAL.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "LSCALE"=>
      ["[in]",
       "         LSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and/or scaling factors applied",
       "         to the left side of A and B, as returned by ZGGBAL."],
     "RSCALE"=>
      ["[in]",
       "         RSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and/or scaling factors applied",
       "         to the right side of A and B, as returned by ZGGBAL."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix V.  M >= 0."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX*16 array, dimension (LDV,M)",
       "         On entry, the matrix of right or left eigenvectors to be",
       "         transformed, as returned by ZTGEVC.",
       "         On exit, V is overwritten by the transformed eigenvectors."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the matrix V. LDV >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dlae2"=>
  {"summary"=>
    ["DLAE2  computes the eigenvalues of a 2-by-2 symmetric matrix",
     "   [  A   B  ]",
     "   [  B   C  ].",
     "On return, RT1 is the eigenvalue of larger absolute value, and RT2",
     "is the eigenvalue of smaller absolute value."],
   "param"=>
    {"A"=>
      ["[in]",
       "         A is DOUBLE PRECISION",
       "         The (1,1) element of the 2-by-2 matrix."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION",
       "         The (1,2) and (2,1) elements of the 2-by-2 matrix."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION",
       "         The (2,2) element of the 2-by-2 matrix."],
     "RT1"=>
      ["[out]",
       "         RT1 is DOUBLE PRECISION",
       "         The eigenvalue of larger absolute value."],
     "RT2"=>
      ["[out]",
       "         RT2 is DOUBLE PRECISION",
       "         The eigenvalue of smaller absolute value."]}},
 "zlansp"=>
  {"summary"=>
    ["ZLANSP  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex symmetric matrix A,  supplied in packed form.",
     "   ZLANSP = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANSP as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is supplied.",
       "         = 'U':  Upper triangular part of A is supplied",
       "         = 'L':  Lower triangular part of A is supplied"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANSP is",
       "         set to zero."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "dspgvd"=>
  {"summary"=>
    ["DSPGVD computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be symmetric, stored in packed format, and B is also",
     "positive definite.",
     "If eigenvectors are desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T, in the same storage",
       "         format as B."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors.  The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the required LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LWORK >= 2*N.",
       "         If JOBZ = 'V' and N > 1, LWORK >= 1 + 6*N + 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the required sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the required LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK >= 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  DPPTRF or DSPEVD returned an error code:",
       "            <= N:  if INFO = i, DSPEVD failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "dtzrzf"=>
  {"summary"=>
    ["DTZRZF reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A",
     "to upper triangular form by means of orthogonal transformations.",
     "The upper trapezoidal matrix A is factored as",
     "   A = ( R  0 ) * Z,",
     "where Z is an N-by-N orthogonal matrix and R is an M-by-M upper",
     "triangular matrix."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= M."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the leading M-by-N upper trapezoidal part of the",
       "         array A must contain the matrix to be factorized.",
       "         On exit, the leading M-by-M upper triangular part of A",
       "         contains the upper triangular matrix R, and elements M+1 to",
       "         N of the first M rows of A, with the array TAU, represent the",
       "         orthogonal matrix Z as a product of M elementary reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (M)",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chptrs"=>
  {"summary"=>
    ["CHPTRS solves a system of linear equations A*X = B with a complex",
     "Hermitian matrix A stored in packed format using the factorization",
     "A = U*D*U**H or A = L*D*L**H computed by CHPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CHPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHPTRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zggesx"=>
  {"summary"=>
    ["ZGGESX computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, the complex Schur form (S,T),",
     "and, optionally, the left and/or right matrices of Schur vectors (VSL",
     "and VSR).  This gives the generalized Schur factorization",
     "     (A,B) = ( (VSL) S (VSR)**H, (VSL) T (VSR)**H )",
     "where (VSR)**H is the conjugate-transpose of VSR.",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "triangular matrix S and the upper triangular matrix T; computes",
     "a reciprocal condition number for the average of the selected",
     "eigenvalues (RCONDE); and computes a reciprocal condition number for",
     "the right and left deflating subspaces corresponding to the selected",
     "eigenvalues (RCONDV). The leading columns of VSL and VSR then form",
     "an orthonormal basis for the corresponding left and right eigenspaces",
     "(deflating subspaces).",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0 or for both being zero.",
     "A pair of matrices (S,T) is in generalized complex Schur form if T is",
     "upper triangular with non-negative diagonal and S is upper",
     "triangular."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG)."],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is procedure) LOGICAL FUNCTION of two COMPLEX*16 arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         Note that a selected complex eigenvalue may no longer satisfy",
       "         SELCTG(ALPHA(j),BETA(j)) = .TRUE. after ordering, since",
       "         ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned), in this",
       "         case INFO is set to N+3 see INFO below)."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N' : None are computed;",
       "         = 'E' : Computed for average of selected eigenvalues only;",
       "         = 'V' : Computed for selected deflating subspaces only;",
       "         = 'B' : Computed for both.",
       "         If SENSE = 'E', 'V', or 'B', SORT must equal 'S'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX*16 array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX*16 array, dimension (N)",
       "         On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the",
       "         generalized eigenvalues.  ALPHA(j) and BETA(j),j=1,...,N  are",
       "         the diagonals of the complex Schur form (S,T).  BETA(j) will",
       "         be non-negative real.",
       "         Note: the quotients ALPHA(j)/BETA(j) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio alpha/beta.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is COMPLEX*16 array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >=1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is COMPLEX*16 array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is DOUBLE PRECISION array, dimension ( 2 )",
       "         If SENSE = 'E' or 'B', RCONDE(1) and RCONDE(2) contain the",
       "         reciprocal condition numbers for the average of the selected",
       "         eigenvalues.",
       "         Not referenced if SENSE = 'N' or 'V'."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is DOUBLE PRECISION array, dimension ( 2 )",
       "         If SENSE = 'V' or 'B', RCONDV(1) and RCONDV(2) contain the",
       "         reciprocal condition number for the selected deflating",
       "         subspaces.",
       "         Not referenced if SENSE = 'N' or 'E'."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N = 0, LWORK >= 1, else if SENSE = 'E', 'V', or 'B',",
       "         LWORK >= MAX(1,2*N,2*SDIM*(N-SDIM)), else",
       "         LWORK >= MAX(1,2*N).  Note that 2*SDIM*(N-SDIM) <= N*N/2.",
       "         Note also that an error is only returned if",
       "         LWORK < MAX(1,2*N), but if SENSE = 'E' or 'V' or 'B' this may",
       "         not be large enough.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the bound on the optimal size of the WORK",
       "         array and the minimum size of the IWORK array, returns these",
       "         values as the first entries of the WORK and IWORK arrays, and",
       "         no error message related to LWORK or LIWORK is issued by",
       "         XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension ( 8*N )",
       "         Real workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If SENSE = 'N' or N = 0, LIWORK >= 1, otherwise",
       "         LIWORK >= N+2.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the bound on the optimal size of the",
       "         WORK array and the minimum size of the IWORK array, returns",
       "         these values as the first entries of the WORK and IWORK",
       "         arrays, and no error message related to LWORK or LIWORK is",
       "         issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHA(j) and BETA(j) should be correct for",
       "               j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in ZHGEQZ",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in ZTGSEN."]}},
 "sppcon"=>
  {"summary"=>
    ["SPPCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric positive definite packed matrix using",
     "the Cholesky factorization A = U**T*U or A = L*L**T computed by",
     "SPPTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, packed columnwise in a linear",
       "         array.  The j-th column of U or L is stored in the array AP",
       "         as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm (or infinity-norm) of the symmetric matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cheev_2stage"=>
  {"summary"=>
    ["CHEEV_2STAGE computes all eigenvalues and, optionally, eigenvectors of a",
     "complex Hermitian matrix A using the 2stage technique for",
     "the reduction to tridiagonal."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is REAL array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "sorbdb"=>
  {"summary"=>
    ["SORBDB simultaneously bidiagonalizes the blocks of an M-by-M",
     "partitioned orthogonal matrix X:",
     "                                [ B11 | B12 0  0 ]",
     "    [ X11 | X12 ]   [ P1 |    ] [  0  |  0 -I  0 ] [ Q1 |    ]**T",
     "X = [-----------] = [---------] [----------------] [---------]   .",
     "    [ X21 | X22 ]   [    | P2 ] [ B21 | B22 0  0 ] [    | Q2 ]",
     "                                [  0  |  0  0  I ]",
     "X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is",
     "not the case, then X must be transposed and/or permuted. This can be",
     "done in constant time using the TRANS and SIGNS options. See SORCSD",
     "for details.)",
     "The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by-",
     "(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are",
     "represented implicitly by Householder vectors.",
     "B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented",
     "implicitly by angles THETA, PHI."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "SIGNS"=>
      ["[in]",
       "         SIGNS is CHARACTER",
       "         = 'O':      The lower-left block is made nonpositive (the",
       "                     \"other\" convention);",
       "         otherwise:  The upper-right block is made nonpositive (the",
       "                     \"default\" convention)."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11 and X12. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <=",
       "         MIN(P,M-P,M-Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is REAL array, dimension (LDX11,Q)",
       "         On entry, the top-left block of the orthogonal matrix to be",
       "         reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the columns of tril(X11) specify reflectors for P1,",
       "            the rows of triu(X11,1) specify reflectors for Q1;",
       "         else TRANS = 'T', and",
       "            the rows of triu(X11) specify reflectors for P1,",
       "            the columns of tril(X11,-1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. If TRANS = 'N', then LDX11 >=",
       "         P; else LDX11 >= Q."],
     "X12"=>
      ["[in,out]",
       "         X12 is REAL array, dimension (LDX12,M-Q)",
       "         On entry, the top-right block of the orthogonal matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the rows of triu(X12) specify the first P reflectors for",
       "            Q2;",
       "         else TRANS = 'T', and",
       "            the columns of tril(X12) specify the first P reflectors",
       "            for Q2."],
     "LDX12"=>
      ["[in]",
       "         LDX12 is INTEGER",
       "         The leading dimension of X12. If TRANS = 'N', then LDX12 >=",
       "         P; else LDX11 >= M-Q."],
     "X21"=>
      ["[in,out]",
       "         X21 is REAL array, dimension (LDX21,Q)",
       "         On entry, the bottom-left block of the orthogonal matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the columns of tril(X21) specify reflectors for P2;",
       "         else TRANS = 'T', and",
       "            the rows of triu(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "         The leading dimension of X21. If TRANS = 'N', then LDX21 >=",
       "         M-P; else LDX21 >= Q."],
     "X22"=>
      ["[in,out]",
       "         X22 is REAL array, dimension (LDX22,M-Q)",
       "         On entry, the bottom-right block of the orthogonal matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the rows of triu(X22(Q+1:M-P,P+1:M-Q)) specify the last",
       "            M-P-Q reflectors for Q2,",
       "         else TRANS = 'T', and",
       "            the columns of tril(X22(P+1:M-Q,Q+1:M-P)) specify the last",
       "            M-P-Q reflectors for P2."],
     "LDX22"=>
      ["[in]",
       "         LDX22 is INTEGER",
       "         The leading dimension of X22. If TRANS = 'N', then LDX22 >=",
       "         M-P; else LDX22 >= M-Q."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (Q)",
       "         The entries of the bidiagonal blocks B11, B12, B21, B22 can",
       "         be computed from the angles THETA and PHI. See Further",
       "         Details."],
     "PHI"=>
      ["[out]",
       "         PHI is REAL array, dimension (Q-1)",
       "         The entries of the bidiagonal blocks B11, B12, B21, B22 can",
       "         be computed from the angles THETA and PHI. See Further",
       "         Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is REAL array, dimension (P)",
       "         The scalar factors of the elementary reflectors that define",
       "         P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is REAL array, dimension (M-P)",
       "         The scalar factors of the elementary reflectors that define",
       "         P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is REAL array, dimension (Q)",
       "         The scalar factors of the elementary reflectors that define",
       "         Q1."],
     "TAUQ2"=>
      ["[out]",
       "         TAUQ2 is REAL array, dimension (M-Q)",
       "         The scalar factors of the elementary reflectors that define",
       "         Q2."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= M-Q.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "spftrf"=>
  {"summary"=>
    ["SPFTRF computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the block version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'T':  The Transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of RFP A is stored;",
       "         = 'L':  Lower triangle of RFP A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension ( N*(N+1)/2 );",
       "         On entry, the symmetric matrix A in RFP format. RFP format is",
       "         described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'",
       "         then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'T' then RFP is",
       "         the transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the NT elements of",
       "         upper packed A. If UPLO = 'L' the RFP A contains the elements",
       "         of lower packed A. The LDA of RFP A is (N+1)/2 when TRANSR =",
       "         'T'. When TRANSR is 'N' the LDA is N+1 when N is even and N",
       "         is odd. See the Note below for more details.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization RFP A = U**T*U or RFP A = L*L**T."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "cgtrfs"=>
  {"summary"=>
    ["CGTRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is tridiagonal, and provides",
     "error bounds and backward error estimates for the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of A."],
     "D"=>
      ["[in]",
       "         D is COMPLEX array, dimension (N)",
       "         The diagonal elements of A."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX array, dimension (N-1)",
       "         The (n-1) superdiagonal elements of A."],
     "DLF"=>
      ["[in]",
       "         DLF is COMPLEX array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A as computed by CGTTRF."],
     "DF"=>
      ["[in]",
       "         DF is COMPLEX array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DUF"=>
      ["[in]",
       "         DUF is COMPLEX array, dimension (N-1)",
       "         The (n-1) elements of the first superdiagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is COMPLEX array, dimension (N-2)",
       "         The (n-2) elements of the second superdiagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by CGTTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dpbrfs"=>
  {"summary"=>
    ["DPBRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric positive definite",
     "and banded, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The upper or lower triangle of the symmetric band matrix A,",
       "         stored in the first KD+1 rows of the array.  The j-th column",
       "         of A is stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "AFB"=>
      ["[in]",
       "         AFB is DOUBLE PRECISION array, dimension (LDAFB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T of the band matrix A as computed by",
       "         DPBTRF, in the same storage format as A (see AB)."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "         The leading dimension of the array AFB.  LDAFB >= KD+1."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by DPBTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "csycon_rook"=>
  {"summary"=>
    ["CSYCON_ROOK estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex symmetric matrix A using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by CSYTRF_ROOK.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF_ROOK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlasdq"=>
  {"summary"=>
    ["DLASDQ computes the singular value decomposition (SVD) of a real",
     "(upper or lower) bidiagonal matrix with diagonal D and offdiagonal",
     "E, accumulating the transformations if desired. Letting B denote",
     "the input bidiagonal matrix, the algorithm computes orthogonal",
     "matrices Q and P such that B = Q * S * P**T (P**T denotes the transpose",
     "of P). The singular values S are overwritten on D.",
     "The input matrix U  is changed to U  * Q  if desired.",
     "The input matrix VT is changed to P**T * VT if desired.",
     "The input matrix C  is changed to Q**T * C  if desired.",
     "See \"Computing  Small Singular Values of Bidiagonal Matrices With",
     "Guaranteed High Relative Accuracy,\" by J. Demmel and W. Kahan,",
     "LAPACK Working Note #3, for a detailed description of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "       On entry, UPLO specifies whether the input bidiagonal matrix",
       "       is upper or lower bidiagonal, and whether it is square are",
       "       not.",
       "          UPLO = 'U' or 'u'   B is upper bidiagonal.",
       "          UPLO = 'L' or 'l'   B is lower bidiagonal."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "       = 0: then the input matrix is N-by-N.",
       "       = 1: then the input matrix is N-by-(N+1) if UPLU = 'U' and",
       "            (N+1)-by-N if UPLU = 'L'.",
       "       The bidiagonal matrix has",
       "       N = NL + NR + 1 rows and",
       "       M = N + SQRE >= N columns."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "       On entry, N specifies the number of rows and columns",
       "       in the matrix. N must be at least 0."],
     "NCVT"=>
      ["[in]",
       "         NCVT is INTEGER",
       "       On entry, NCVT specifies the number of columns of",
       "       the matrix VT. NCVT must be at least 0."],
     "NRU"=>
      ["[in]",
       "         NRU is INTEGER",
       "       On entry, NRU specifies the number of rows of",
       "       the matrix U. NRU must be at least 0."],
     "NCC"=>
      ["[in]",
       "         NCC is INTEGER",
       "       On entry, NCC specifies the number of columns of",
       "       the matrix C. NCC must be at least 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "       On entry, D contains the diagonal entries of the",
       "       bidiagonal matrix whose SVD is desired. On normal exit,",
       "       D contains the singular values in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array.",
       "       dimension is (N-1) if SQRE = 0 and N if SQRE = 1.",
       "       On entry, the entries of E contain the offdiagonal entries",
       "       of the bidiagonal matrix whose SVD is desired. On normal",
       "       exit, E will contain 0. If the algorithm does not converge,",
       "       D and E will contain the diagonal and superdiagonal entries",
       "       of a bidiagonal matrix orthogonally equivalent to the one",
       "       given as input."],
     "VT"=>
      ["[in,out]",
       "         VT is DOUBLE PRECISION array, dimension (LDVT, NCVT)",
       "       On entry, contains a matrix which on exit has been",
       "       premultiplied by P**T, dimension N-by-NCVT if SQRE = 0",
       "       and (N+1)-by-NCVT if SQRE = 1 (not referenced if NCVT=0)."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "       On entry, LDVT specifies the leading dimension of VT as",
       "       declared in the calling (sub) program. LDVT must be at",
       "       least 1. If NCVT is nonzero LDVT must also be at least N."],
     "U"=>
      ["[in,out]",
       "         U is DOUBLE PRECISION array, dimension (LDU, N)",
       "       On entry, contains a  matrix which on exit has been",
       "       postmultiplied by Q, dimension NRU-by-N if SQRE = 0",
       "       and NRU-by-(N+1) if SQRE = 1 (not referenced if NRU=0)."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "       On entry, LDU  specifies the leading dimension of U as",
       "       declared in the calling (sub) program. LDU must be at",
       "       least max( 1, NRU ) ."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC, NCC)",
       "       On entry, contains an N-by-NCC matrix which on exit",
       "       has been premultiplied by Q**T  dimension N-by-NCC if SQRE = 0",
       "       and (N+1)-by-NCC if SQRE = 1 (not referenced if NCC=0)."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "       On entry, LDC  specifies the leading dimension of C as",
       "       declared in the calling (sub) program. LDC must be at",
       "       least 1. If NCC is nonzero, LDC must also be at least N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (4*N)",
       "       Workspace. Only referenced if one of NCVT, NRU, or NCC is",
       "       nonzero, and if N is at least 2."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "       On exit, a value of 0 indicates a successful exit.",
       "       If INFO < 0, argument number -INFO is illegal.",
       "       If INFO > 0, the algorithm did not converge, and INFO",
       "       specifies how many superdiagonals did not converge."]}},
 "slansf"=>
  {"summary"=>
    ["SLANSF returns the value of the one norm, or the Frobenius norm, or",
     "the infinity norm, or the element of largest absolute value of a",
     "real symmetric matrix A in RFP format.",
     "   SLANSF = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a  matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANSF as described",
       "         above."],
     "TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         Specifies whether the RFP format of A is normal or",
       "         transposed format.",
       "         = 'N':  RFP format is Normal;",
       "         = 'T':  RFP format is Transpose."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the RFP matrix A came from",
       "          an upper or lower triangular matrix as follows:",
       "          = 'U': RFP A came from an upper triangular matrix;",
       "          = 'L': RFP A came from a lower triangular matrix."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0. When N = 0, SLANSF is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension ( N*(N+1)/2 );",
       "         On entry, the upper (if UPLO = 'U') or lower (if UPLO = 'L')",
       "         part of the symmetric matrix A stored in RFP format. See the",
       "         \"Notes\" below for more details.",
       "         Unchanged on exit."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "slaqgb"=>
  {"summary"=>
    ["SLAQGB equilibrates a general M by N band matrix A with KL",
     "subdiagonals and KU superdiagonals using the row and scaling factors",
     "in the vectors R and C."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, the equilibrated matrix, in the same storage format",
       "         as A.  See EQUED for the form of the equilibrated matrix."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDA >= KL+KU+1."],
     "R"=>
      ["[in]",
       "         R is REAL array, dimension (M)",
       "         The row scale factors for A."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "         The column scale factors for A."],
     "ROWCND"=>
      ["[in]",
       "         ROWCND is REAL",
       "         Ratio of the smallest R(i) to the largest R(i)."],
     "COLCND"=>
      ["[in]",
       "         COLCND is REAL",
       "         Ratio of the smallest C(i) to the largest C(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies the form of equilibration that was done.",
       "         = 'N':  No equilibration",
       "         = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "                 diag(R).",
       "         = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "                 by diag(C).",
       "         = 'B':  Both row and column equilibration, i.e., A has been",
       "                 replaced by diag(R) * A * diag(C)."]}},
 "cladiv"=>
  {"summary"=>
    ["CLADIV := X / Y, where X and Y are complex.  The computation of X / Y",
     "will not overflow on an intermediary step unless the results",
     "overflows."],
   "param"=>
    {"X"=>["[in]", "         X is COMPLEX"],
     "Y"=>
      ["[in]",
       "         Y is COMPLEX",
       "         The complex scalars X and Y."]}},
 "zunbdb1"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <=",
       "          MIN(P,M-P,M-Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX*16 array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX*16 array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is COMPLEX*16 array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is COMPLEX*16 array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is COMPLEX*16 array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dlargv"=>
  {"summary"=>
    ["DLARGV generates a vector of real plane rotations, determined by",
     "elements of the real vectors x and y. For i = 1,2,...,n",
     "   (  c(i)  s(i) ) ( x(i) ) = ( a(i) )",
     "   ( -s(i)  c(i) ) ( y(i) ) = (   0  )"],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be generated."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array,",
       "                        dimension (1+(N-1)*INCX)",
       "         On entry, the vector x.",
       "         On exit, x(i) is overwritten by a(i), for i = 1,...,n."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array,",
       "                        dimension (1+(N-1)*INCY)",
       "         On entry, the vector y.",
       "         On exit, the sines of the plane rotations."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between elements of Y. INCY > 0."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C. INCC > 0."]}},
 "strti2"=>
  {"summary"=>
    ["STRTI2 computes the inverse of a real upper or lower triangular",
     "matrix.",
     "This is the Level 2 BLAS version of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading n by n upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced.  If DIAG = 'U', the",
       "         diagonal elements of A are also not referenced and are",
       "         assumed to be 1.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "chbevx"=>
  {"summary"=>
    ["CHBEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian band matrix A.  Eigenvalues and eigenvectors",
     "can be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the N-by-N unitary matrix used in the",
       "                         reduction to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'V', then",
       "         LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AB to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "ssyrfs"=>
  {"summary"=>
    ["SSYRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric indefinite, and",
     "provides error bounds and backward error estimates for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "         The factored form of the matrix A.  AF contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**T or",
       "         A = L*D*L**T as computed by SSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by SSYTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zsysvxx"=>
  {"summary"=>
    ["   ZSYSVXX uses the diagonal pivoting factorization to compute the",
     "   solution to a complex*16 system of linear equations A * X = B, where",
     "   A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "   matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. ZSYSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   ZSYSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   ZSYSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what ZSYSVXX would itself produce."],
   "param"=>nil},
 "cpocon"=>
  {"summary"=>
    ["CPOCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex Hermitian positive definite matrix using the",
     "Cholesky factorization A = U**H*U or A = L*L**H computed by CPOTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H, as computed by CPOTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm (or infinity-norm) of the Hermitian matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dptcon"=>
  {"summary"=>
    ["DPTCON computes the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric positive definite tridiagonal matrix",
     "using the factorization A = L*D*L**T or A = U**T*D*U computed by",
     "DPTTRF.",
     "Norm(inv(A)) is computed by a direct method, and the reciprocal of",
     "the condition number is computed as",
     "             RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         factorization of A, as computed by DPTTRF."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the unit bidiagonal factor",
       "         U or L from the factorization of A,  as computed by DPTTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is the",
       "         1-norm of inv(A) computed in this routine."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zsytf2_rook"=>
  {"summary"=>
    ["ZSYTF2_ROOK computes the factorization of a complex symmetric matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**T is the transpose of U, and D is symmetric and",
     "block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "sormhr"=>
  {"summary"=>
    ["SORMHR overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "IHI-ILO elementary reflectors, as returned by SGEHRD:",
     "Q = H(ilo) H(ilo+1) . . . H(ihi-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI must have the same values as in the previous call",
       "         of SGEHRD. Q is equal to the unit matrix except in the",
       "         submatrix Q(ilo+1:ihi,ilo+1:ihi).",
       "         If SIDE = 'L', then 1 <= ILO <= IHI <= M, if M > 0, and",
       "         ILO = 1 and IHI = 0, if M = 0;",
       "         if SIDE = 'R', then 1 <= ILO <= IHI <= N, if N > 0, and",
       "         ILO = 1 and IHI = 0, if N = 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension",
       "                              (LDA,M) if SIDE = 'L'",
       "                              (LDA,N) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by SGEHRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension",
       "                              (M-1) if SIDE = 'L'",
       "                              (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGEHRD."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For optimum performance LWORK >= N*NB if SIDE = 'L', and",
       "         LWORK >= M*NB if SIDE = 'R', where NB is the optimal",
       "         blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhetri_rook"=>
  {"summary"=>
    ["ZHETRI_ROOK computes the inverse of a complex Hermitian indefinite matrix",
     "A using the factorization A = U*D*U**H or A = L*D*L**H computed by",
     "ZHETRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by ZHETRF_ROOK.",
       "         On exit, if INFO = 0, the (Hermitian) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHETRF_ROOK."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "cptts2"=>
  {"summary"=>
    ["CPTTS2 solves a tridiagonal system of the form",
     "   A * X = B",
     "using the factorization A = U**H*D*U or A = L*D*L**H computed by CPTTRF.",
     "D is a diagonal matrix specified in the vector D, U (or L) is a unit",
     "bidiagonal matrix whose superdiagonal (subdiagonal) is specified in",
     "the vector E, and X and B are N by NRHS matrices."],
   "param"=>
    {"IUPLO"=>
      ["[in]",
       "         IUPLO is INTEGER",
       "         Specifies the form of the factorization and whether the",
       "         vector E is the superdiagonal of the upper bidiagonal factor",
       "         U or the subdiagonal of the lower bidiagonal factor L.",
       "         = 1:  A = U**H *D*U, E is the superdiagonal of U",
       "         = 0:  A = L*D*L**H, E is the subdiagonal of L"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         factorization A = U**H *D*U or A = L*D*L**H."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N-1)",
       "         If IUPLO = 1, the (n-1) superdiagonal elements of the unit",
       "         bidiagonal factor U from the factorization A = U**H*D*U.",
       "         If IUPLO = 0, the (n-1) subdiagonal elements of the unit",
       "         bidiagonal factor L from the factorization A = L*D*L**H."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side vectors B for the system of",
       "         linear equations.",
       "         On exit, the solution vectors, X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."]}},
 "zhbevd"=>
  {"summary"=>
    ["ZHBEVD computes all the eigenvalues and, optionally, eigenvectors of",
     "a complex Hermitian band matrix A.  If eigenvectors are desired, it",
     "uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be at least N.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array,",
       "                                        dimension (LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK.",
       "         If N <= 1,               LRWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LRWORK must be at least N.",
       "         If JOBZ = 'V' and N > 1, LRWORK must be at least",
       "                       1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of array IWORK.",
       "         If JOBZ = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ = 'V' and N > 1, LIWORK must be at least 3 + 5*N .",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "slantr"=>
  {"summary"=>
    ["SLANTR  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "trapezoidal or triangular matrix A.",
     "   SLANTR = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANTR as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower trapezoidal.",
       "         = 'U':  Upper trapezoidal",
       "         = 'L':  Lower trapezoidal",
       "         Note that A is triangular instead of trapezoidal if M = N."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A has unit diagonal.",
       "         = 'N':  Non-unit diagonal",
       "         = 'U':  Unit diagonal"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0, and if",
       "         UPLO = 'U', M <= N.  When M = 0, SLANTR is set to zero."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0, and if",
       "         UPLO = 'L', N <= M.  When N = 0, SLANTR is set to zero."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The trapezoidal matrix A (A is triangular if M = N).",
       "         If UPLO = 'U', the leading m by n upper trapezoidal part of",
       "         the array A contains the upper trapezoidal matrix, and the",
       "         strictly lower triangular part of A is not referenced.",
       "         If UPLO = 'L', the leading m by n lower trapezoidal part of",
       "         the array A contains the lower trapezoidal matrix, and the",
       "         strictly upper triangular part of A is not referenced.  Note",
       "         that when DIAG = 'U', the diagonal elements of A are not",
       "         referenced and are assumed to be one."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= M when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "slasq3"=>
  {"summary"=>
    ["SLASQ3 checks for deflation, computes a shift (TAU) and calls dqds.",
     "In case of failure it changes shifts, and tries again until output",
     "is positive."],
   "param"=>
    {"I0"=>["[in]", "         I0 is INTEGER", "        First index."],
     "N0"=>["[in,out]", "         N0 is INTEGER", "        Last index."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension ( 4*N0 )",
       "        Z holds the qd array."],
     "PP"=>
      ["[in,out]",
       "         PP is INTEGER",
       "        PP=0 for ping, PP=1 for pong.",
       "        PP=2 indicates that flipping was applied to the Z array",
       "        and that the initial tests for deflation should not be",
       "        performed."],
     "DMIN"=>["[out]", "         DMIN is REAL", "        Minimum value of d."],
     "SIGMA"=>
      ["[out]",
       "         SIGMA is REAL",
       "        Sum of shifts used in current segment."],
     "DESIG"=>
      ["[in,out]",
       "         DESIG is REAL",
       "        Lower order part of SIGMA"],
     "QMAX"=>["[in]", "         QMAX is REAL", "        Maximum value of q."],
     "NFAIL"=>
      ["[in,out]",
       "         NFAIL is INTEGER",
       "        Increment NFAIL by 1 each time the shift was too big."],
     "ITER"=>
      ["[in,out]",
       "         ITER is INTEGER",
       "        Increment ITER by 1 for each iteration."],
     "NDIV"=>
      ["[in,out]",
       "         NDIV is INTEGER",
       "        Increment NDIV by 1 for each division."],
     "IEEE"=>
      ["[in]",
       "         IEEE is LOGICAL",
       "        Flag for IEEE or non IEEE arithmetic (passed to SLASQ5)."],
     "TTYPE"=>["[in,out]", "         TTYPE is INTEGER", "        Shift type."],
     "DMIN1"=>["[in,out]", "         DMIN1 is REAL"],
     "DMIN2"=>["[in,out]", "         DMIN2 is REAL"],
     "DN"=>["[in,out]", "         DN is REAL"],
     "DN1"=>["[in,out]", "         DN1 is REAL"],
     "DN2"=>["[in,out]", "         DN2 is REAL"],
     "G"=>["[in,out]", "         G is REAL"],
     "TAU"=>
      ["[in,out]",
       "         TAU is REAL",
       "        These are passed as arguments in order to save their values",
       "        between calls to SLASQ3."]}},
 "zhetri2"=>
  {"summary"=>
    ["ZHETRI2 computes the inverse of a COMPLEX*16 hermitian indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "ZHETRF. ZHETRI2 set the LEADING DIMENSION of the workspace",
     "before calling ZHETRI2X that actually computes the inverse."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by ZHETRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NB structure of D",
       "         as determined by ZHETRF."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (N+NB+1)*(NB+3)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         WORK is size >= (N+NB+1)*(NB+3)",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "          calculates:",
       "             - the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array,",
       "             - and no error message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "zgttrf"=>
  {"summary"=>
    ["ZGTTRF computes an LU factorization of a complex tridiagonal matrix A",
     "using elimination with partial pivoting and row interchanges.",
     "The factorization has the form",
     "   A = L * U",
     "where L is a product of permutation and unit lower bidiagonal",
     "matrices and U is upper triangular with nonzeros in only the main",
     "diagonal and first two superdiagonals."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "DL"=>
      ["[in,out]",
       "         DL is COMPLEX*16 array, dimension (N-1)",
       "         On entry, DL must contain the (n-1) sub-diagonal elements of",
       "         A.",
       "         On exit, DL is overwritten by the (n-1) multipliers that",
       "         define the matrix L from the LU factorization of A."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX*16 array, dimension (N)",
       "         On entry, D must contain the diagonal elements of A.",
       "         On exit, D is overwritten by the n diagonal elements of the",
       "         upper triangular matrix U from the LU factorization of A."],
     "DU"=>
      ["[in,out]",
       "         DU is COMPLEX*16 array, dimension (N-1)",
       "         On entry, DU must contain the (n-1) super-diagonal elements",
       "         of A.",
       "         On exit, DU is overwritten by the (n-1) elements of the first",
       "         super-diagonal of U."],
     "DU2"=>
      ["[out]",
       "         DU2 is COMPLEX*16 array, dimension (N-2)",
       "         On exit, DU2 is overwritten by the (n-2) elements of the",
       "         second super-diagonal of U."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value",
       "         > 0:  if INFO = k, U(k,k) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "sgetri"=>
  {"summary"=>
    ["SGETRI computes the inverse of a matrix using the LU factorization",
     "computed by SGETRF.",
     "This method inverts U and then computes inv(A) by solving the system",
     "inv(A)*L = inv(U) for inv(A)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the factors L and U from the factorization",
       "         A = P*L*U as computed by SGETRF.",
       "         On exit, if INFO = 0, the inverse of the original matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from SGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO=0, then WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimal performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero; the matrix is",
       "               singular and its inverse could not be computed."]}},
 "claqp2"=>
  {"summary"=>
    ["CLAQP2 computes a QR factorization with column pivoting of",
     "the block A(OFFSET+1:M,1:N).",
     "The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0."],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         The number of rows of the matrix A that must be pivoted",
       "         but no factorized. OFFSET >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the upper triangle of block A(OFFSET+1:M,1:N) is",
       "         the triangular factor obtained; the elements in block",
       "         A(OFFSET+1:M,1:N) below the diagonal, together with the",
       "         array TAU, represent the orthogonal matrix Q as a product of",
       "         elementary reflectors. Block A(1:OFFSET,1:N) has been",
       "         accordingly pivoted, but no factorized."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(i) .ne. 0, the i-th column of A is permuted",
       "         to the front of A*P (a leading column); if JPVT(i) = 0,",
       "         the i-th column of A is a free column.",
       "         On exit, if JPVT(i) = k, then the i-th column of A*P",
       "         was the k-th column of A."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors."],
     "VN1"=>
      ["[in,out]",
       "         VN1 is REAL array, dimension (N)",
       "         The vector with the partial column norms."],
     "VN2"=>
      ["[in,out]",
       "         VN2 is REAL array, dimension (N)",
       "         The vector with the exact column norms."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"]}},
 "cpptri"=>
  {"summary"=>
    ["CPPTRI computes the inverse of a complex Hermitian positive definite",
     "matrix A using the Cholesky factorization A = U**H*U or A = L*L**H",
     "computed by CPPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor is stored in AP;",
       "         = 'L':  Lower triangular factor is stored in AP."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the triangular factor U or L from the Cholesky",
       "         factorization A = U**H*U or A = L*L**H, packed columnwise as",
       "         a linear array.  The j-th column of U or L is stored in the",
       "         array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n.",
       "         On exit, the upper or lower triangle of the (Hermitian)",
       "         inverse of A, overwriting the input factor U or L."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "dgeqrfp"=>
  {"summary"=>
    ["DGEQRFP computes a QR factorization of a real M-by-N matrix A:",
     "A = Q * R. The diagonal entries of R are nonnegative."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n). The diagonal entries of R",
       "         are nonnegative; the elements below the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of min(m,n) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zla_gbrfsx_extended"=>
  {"summary"=>
    ["ZLA_GBRFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by ZGBRFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "TRANS_TYPE"=>
      ["[in]",
       "         TRANS_TYPE is INTEGER",
       "    Specifies the transposition operation on A.",
       "    The value is defined by ILATRANS(T) where T is a CHARACTER and",
       "    T    = 'N':  No transpose",
       "         = 'T':  Transpose",
       "         = 'C':  Conjugate transpose"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0"],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "    On entry, the N-by-N matrix A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array A.  LDAB >= max(1,N)."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX*16 array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by ZGBTRF."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by ZGBTRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by ZGBTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by ZLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is DOUBLE PRECISION array, dimension (N)",
       "    Workspace."],
     "DY"=>
      ["[in]",
       "         DY is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is DOUBLE PRECISION",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is DOUBLE PRECISION",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to ZGBTRS had an illegal",
       "            value"]}},
 "dtrsyl"=>
  {"summary"=>
    ["DTRSYL solves the real Sylvester matrix equation:",
     "   op(A)*X + X*op(B) = scale*C or",
     "   op(A)*X - X*op(B) = scale*C,",
     "where op(A) = A or A**T, and  A and B are both upper quasi-",
     "triangular. A is M-by-M and B is N-by-N; the right hand side C and",
     "the solution X are M-by-N; and scale is an output scale factor, set",
     "<= 1 to avoid overflow in X.",
     "A and B must be in Schur canonical form (as returned by DHSEQR), that",
     "is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks;",
     "each 2-by-2 diagonal block has its diagonal elements equal and its",
     "off-diagonal elements of opposite sign."],
   "param"=>
    {"TRANA"=>
      ["[in]",
       "         TRANA is CHARACTER*1",
       "         Specifies the option op(A):",
       "         = 'N': op(A) = A    (No transpose)",
       "         = 'T': op(A) = A**T (Transpose)",
       "         = 'C': op(A) = A**H (Conjugate transpose = Transpose)"],
     "TRANB"=>
      ["[in]",
       "         TRANB is CHARACTER*1",
       "         Specifies the option op(B):",
       "         = 'N': op(B) = B    (No transpose)",
       "         = 'T': op(B) = B**T (Transpose)",
       "         = 'C': op(B) = B**H (Conjugate transpose = Transpose)"],
     "ISGN"=>
      ["[in]",
       "         ISGN is INTEGER",
       "         Specifies the sign in the equation:",
       "         = +1: solve op(A)*X + X*op(B) = scale*C",
       "         = -1: solve op(A)*X - X*op(B) = scale*C"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The order of the matrix A, and the number of rows in the",
       "         matrices X and C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix B, and the number of columns in the",
       "         matrices X and C. N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,M)",
       "         The upper quasi-triangular matrix A, in Schur canonical form."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         The upper quasi-triangular matrix B, in Schur canonical form."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N right hand side matrix C.",
       "         On exit, C is overwritten by the solution matrix X."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)"],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         The scale factor, scale, set <= 1 to avoid overflow in X."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         = 1: A and B have common or very close eigenvalues; perturbed",
       "              values were used to solve the equation (but the matrices",
       "              A and B are unchanged)."]}},
 "stpqrt2"=>
  {"summary"=>
    ["STPQRT2 computes a QR factorization of a real \"triangular-pentagonal\"",
     "matrix C, which is composed of a triangular block A and pentagonal block B,",
     "using the compact WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of",
       "         the triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the upper trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the upper triangular N-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first M-L rows",
       "         are rectangular, and the last L rows are upper trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor T of the block reflector.",
       "         See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "cgges"=>
  {"summary"=>
    ["CGGES computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, the generalized complex Schur",
     "form (S, T), and optionally left and/or right Schur vectors (VSL",
     "and VSR). This gives the generalized Schur factorization",
     "        (A,B) = ( (VSL)*S*(VSR)**H, (VSL)*T*(VSR)**H )",
     "where (VSR)**H is the conjugate-transpose of VSR.",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "triangular matrix S and the upper triangular matrix T. The leading",
     "columns of VSL and VSR then form an unitary basis for the",
     "corresponding left and right eigenspaces (deflating subspaces).",
     "(If only the generalized eigenvalues are needed, use the driver",
     "CGGEV instead, which is faster.)",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0, and even for both being zero.",
     "A pair of matrices (S,T) is in generalized complex Schur form if S",
     "and T are upper triangular and, in addition, the diagonal elements",
     "of T are non-negative real numbers."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG)."],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is a LOGICAL FUNCTION of two COMPLEX arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         An eigenvalue ALPHA(j)/BETA(j) is selected if",
       "         SELCTG(ALPHA(j),BETA(j)) is true.",
       "         Note that a selected complex eigenvalue may no longer satisfy",
       "         SELCTG(ALPHA(j),BETA(j)) = .TRUE. after ordering, since",
       "         ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned), in this",
       "         case INFO is set to N+2 (See INFO below)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX array, dimension (N)",
       "         On exit,  ALPHA(j)/BETA(j), j=1,...,N, will be the",
       "         generalized eigenvalues.  ALPHA(j), j=1,...,N  and  BETA(j),",
       "         j=1,...,N  are the diagonals of the complex Schur form (A,B)",
       "         output by CGGES. The  BETA(j) will be non-negative real.",
       "         Note: the quotients ALPHA(j)/BETA(j) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio alpha/beta.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is COMPLEX array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >= 1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is COMPLEX array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,2*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (8*N)"],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         =1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHA(j) and BETA(j) should be correct for",
       "               j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in CHGEQZ",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in CTGSEN."]}},
 "zpttrf"=>
  {"summary"=>
    ["ZPTTRF computes the L*D*L**H factorization of a complex Hermitian",
     "positive definite tridiagonal matrix A.  The factorization may also",
     "be regarded as having the form A = U**H *D*U."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.  On exit, the n diagonal elements of the diagonal matrix",
       "         D from the L*D*L**H factorization of A."],
     "E"=>
      ["[in,out]",
       "         E is COMPLEX*16 array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A.  On exit, the (n-1) subdiagonal elements of the",
       "         unit bidiagonal factor L from the L*D*L**H factorization of A.",
       "         E can also be regarded as the superdiagonal of the unit",
       "         bidiagonal factor U from the U**H *D*U factorization of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite; if k < N, the factorization could not",
       "              be completed, while if k = N, the factorization was",
       "              completed, but D(N) <= 0."]}},
 "sgeqrt2"=>
  {"summary"=>
    ["SGEQRT2 computes a QR factorization of a real M-by-N matrix A,",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the real M-by-N matrix A.  On exit, the elements on and",
       "         above the diagonal contain the N-by-N upper triangular matrix R; the",
       "         elements below the diagonal are the columns of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "sgges3"=>
  {"summary"=>
    ["SGGES3 computes for a pair of N-by-N real nonsymmetric matrices (A,B),",
     "the generalized eigenvalues, the generalized real Schur form (S,T),",
     "optionally, the left and/or right matrices of Schur vectors (VSL and",
     "VSR). This gives the generalized Schur factorization",
     "         (A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T )",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "quasi-triangular matrix S and the upper triangular matrix T.The",
     "leading columns of VSL and VSR then form an orthonormal basis for the",
     "corresponding left and right eigenspaces (deflating subspaces).",
     "(If only the generalized eigenvalues are needed, use the driver",
     "SGGEV instead, which is faster.)",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0 or both being zero.",
     "A pair of matrices (S,T) is in generalized real Schur form if T is",
     "upper triangular with non-negative diagonal and S is block upper",
     "triangular with 1-by-1 and 2-by-2 blocks.  1-by-1 blocks correspond",
     "to real generalized eigenvalues, while 2-by-2 blocks of S will be",
     "\"standardized\" by making the corresponding elements of T have the",
     "form:",
     "        [  a  0  ]",
     "        [  0  b  ]",
     "and the pair of corresponding 2-by-2 blocks in S and T will have a",
     "complex conjugate pair of generalized eigenvalues."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG);"],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is a LOGICAL FUNCTION of three REAL arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         An eigenvalue (ALPHAR(j)+ALPHAI(j))/BETA(j) is selected if",
       "         SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) is true; i.e. if either",
       "         one of a complex conjugate pair of eigenvalues is selected,",
       "         then both complex eigenvalues are selected.",
       "         Note that in the ill-conditioned case, a selected complex",
       "         eigenvalue may no longer satisfy SELCTG(ALPHAR(j),ALPHAI(j),",
       "         BETA(j)) = .TRUE. after ordering. INFO is to be set to N+2",
       "         in this case."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true.  (Complex conjugate pairs for which",
       "         SELCTG is true for either eigenvalue count as 2.)"],
     "ALPHAR"=>["[out]", "         ALPHAR is REAL array, dimension (N)"],
     "ALPHAI"=>["[out]", "         ALPHAI is REAL array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  ALPHAR(j) + ALPHAI(j)*i,",
       "         and  BETA(j),j=1,...,N are the diagonals of the complex Schur",
       "         form (S,T) that would result if the 2-by-2 diagonal blocks of",
       "         the real Schur form of (A,B) were further reduced to",
       "         triangular form using 2-by-2 complex unitary transformations.",
       "         If ALPHAI(j) is zero, then the j-th eigenvalue is real; if",
       "         positive, then the j-th and (j+1)-st eigenvalues are a",
       "         complex conjugate pair, with ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio.",
       "         However, ALPHAR and ALPHAI will be always less than and",
       "         usually comparable with norm(A) in magnitude, and BETA always",
       "         less than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is REAL array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >=1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is REAL array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHAR(j), ALPHAI(j), and BETA(j) should",
       "               be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in SHGEQZ.",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in STGSEN."]}},
 "spotf2"=>
  {"summary"=>
    ["SPOTF2 computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**T * U ,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**T *U  or A = L*L**T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite, and the factorization could not be",
       "              completed."]}},
 "dsytri"=>
  {"summary"=>
    ["DSYTRI computes the inverse of a real symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "DSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by DSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "sorml2"=>
  {"summary"=>
    ["SORML2 overwrites the general real m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**T* C  if SIDE = 'L' and TRANS = 'T', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**T if SIDE = 'R' and TRANS = 'T',",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by SGELQF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left",
       "         = 'R': apply Q or Q**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'T': apply Q**T (Transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         SGELQF in the first k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGELQF."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dposv"=>
  {"summary"=>
    ["DPOSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite matrix and X and B",
     "are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**T* U,  if UPLO = 'U', or",
     "   A = L * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is a lower triangular",
     "matrix.  The factored form of A is then used to solve the system of",
     "equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "sgebrd"=>
  {"summary"=>
    ["SGEBRD reduces a general real M-by-N matrix A to upper or lower",
     "bidiagonal form B by an orthogonal transformation: Q**T * A * P = B.",
     "If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N general matrix to be reduced.",
       "         On exit,",
       "         if m >= n, the diagonal and the first superdiagonal are",
       "           overwritten with the upper bidiagonal matrix B; the",
       "           elements below the diagonal, with the array TAUQ, represent",
       "           the orthogonal matrix Q as a product of elementary",
       "           reflectors, and the elements above the first superdiagonal,",
       "           with the array TAUP, represent the orthogonal matrix P as",
       "           a product of elementary reflectors;",
       "         if m < n, the diagonal and the first subdiagonal are",
       "           overwritten with the lower bidiagonal matrix B; the",
       "           elements below the first subdiagonal, with the array TAUQ,",
       "           represent the orthogonal matrix Q as a product of",
       "           elementary reflectors, and the elements above the diagonal,",
       "           with the array TAUP, represent the orthogonal matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (min(M,N)-1)",
       "         The off-diagonal elements of the bidiagonal matrix B:",
       "         if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;",
       "         if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is REAL array dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix P. See Further Details."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,M,N).",
       "         For optimum performance LWORK >= (M+N)*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dsytrf"=>
  {"summary"=>
    ["DSYTRF computes the factorization of a real symmetric matrix A using",
     "the Bunch-Kaufman diagonal pivoting method.  The form of the",
     "factorization is",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "slarrr"=>
  {"summary"=>
    ["Perform tests to decide whether the symmetric tridiagonal matrix T",
     "warrants expensive computations which guarantee high relative accuracy",
     "in the eigenvalues."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix. N > 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The N diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N)",
       "         On entry, the first (N-1) entries contain the subdiagonal",
       "         elements of the tridiagonal matrix T; E(N) is set to ZERO."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         INFO = 0(default) : the matrix warrants computations preserving",
       "                             relative accuracy.",
       "         INFO = 1          : the matrix warrants computations guaranteeing",
       "                             only absolute accuracy."]}},
 "zgebal"=>
  {"summary"=>
    ["ZGEBAL balances a general complex matrix A.  This involves, first,",
     "permuting A by a similarity transformation to isolate eigenvalues",
     "in the first 1 to ILO-1 and last IHI+1 to N elements on the",
     "diagonal; and second, applying a diagonal similarity transformation",
     "to rows and columns ILO to IHI to make the rows and columns as",
     "close in norm as possible.  Both steps are optional.",
     "Balancing may reduce the 1-norm of the matrix, and improve the",
     "accuracy of the computed eigenvalues and/or eigenvectors."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the operations to be performed on A:",
       "         = 'N':  none:  simply set ILO = 1, IHI = N, SCALE(I) = 1.0",
       "                 for i = 1,...,N;",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the input matrix A.",
       "         On exit,  A is overwritten by the balanced matrix.",
       "         If JOB = 'N', A is not referenced.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ILO"=>["[out]"],
     "IHI"=>
      ["[out]",
       "         ILO and IHI are set to INTEGER such that on exit",
       "         A(i,j) = 0 if i > j and j = 1,...,ILO-1 or I = IHI+1,...,N.",
       "         If JOB = 'N' or 'S', ILO = 1 and IHI = N."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and scaling factors applied to",
       "         A.  If P(j) is the index of the row and column interchanged",
       "         with row and column j and D(j) is the scaling factor",
       "         applied to row and column j, then",
       "         SCALE(j) = P(j)    for j = 1,...,ILO-1",
       "                  = D(j)    for j = ILO,...,IHI",
       "                  = P(j)    for j = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "chpgst"=>
  {"summary"=>
    ["CHPGST reduces a complex Hermitian-definite generalized",
     "eigenproblem to standard form, using packed storage.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L.",
     "B must have been previously factorized as U**H*U or L*L**H by CPPTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H);",
       "         = 2 or 3: compute U*A*U**H or L**H*A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored and B is factored as",
       "                 U**H*U;",
       "         = 'L':  Lower triangle of A is stored and B is factored as",
       "                 L*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "BP"=>
      ["[in]",
       "         BP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         stored in the same format as A, as returned by CPPTRF."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlahr2"=>
  {"summary"=>
    ["DLAHR2 reduces the first NB columns of A real general n-BY-(n-k+1)",
     "matrix A so that elements below the k-th subdiagonal are zero. The",
     "reduction is performed by an orthogonal similarity transformation",
     "Q**T * A * Q. The routine returns the matrices V and T which determine",
     "Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T.",
     "This is an auxiliary routine called by DGEHRD."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The offset for the reduction. Elements below the k-th",
       "         subdiagonal in the first NB columns are reduced to zero.",
       "         K < N."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of columns to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N-K+1)",
       "         On entry, the n-by-(n-k+1) general matrix A.",
       "         On exit, the elements on and above the k-th subdiagonal in",
       "         the first NB columns are overwritten with the corresponding",
       "         elements of the reduced matrix; the elements below the k-th",
       "         subdiagonal, with the array TAU, represent the matrix Q as a",
       "         product of elementary reflectors. The other columns of A are",
       "         unchanged. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (NB)",
       "         The scalar factors of the elementary reflectors. See Further",
       "         Details."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,NB)",
       "         The upper triangular matrix T."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "Y"=>
      ["[out]",
       "         Y is DOUBLE PRECISION array, dimension (LDY,NB)",
       "         The n-by-nb matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "         The leading dimension of the array Y. LDY >= N."]}},
 "zlasyf_aa"=>
  {"summary"=>
    ["DLATRF_AA factorizes a panel of a complex symmetric matrix A using",
     "the Aasen's algorithm. The panel consists of a set of NB rows of A",
     "when UPLO is U, or a set of NB columns when UPLO is L.",
     "In order to factorize the panel, the Aasen's algorithm requires the",
     "last row, or column, of the previous panel. The first row, or column,",
     "of A is set to be the first row, or column, of an identity matrix,",
     "which is used to factorize the first panel.",
     "The resulting J-th row of U, or J-th column of L, is stored in the",
     "(J-1)-th row, or column, of A (without the unit diagonals), while",
     "the diagonal and subdiagonal of A are overwritten by those of T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The location of the first row, or column, of the panel",
       "         within the submatrix of A, passed to this routine, e.g.,",
       "         when called by ZSYTRF_AA, for the first panel, J1 is 1,",
       "         while for the remaining panels, J1 is 2."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The dimension of the submatrix. M >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The dimension of the panel to be facotorized."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,M) for",
       "         the first panel, while dimension (LDA,M+1) for the",
       "         remaining panels.",
       "         On entry, A contains the last row, or column, of",
       "         the previous panel, and the trailing submatrix of A",
       "         to be factorized, except for the first panel, only",
       "         the panel is passed.",
       "         On exit, the leading panel is factorized."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the row and column interchanges,",
       "         the row and column k were interchanged with the row and",
       "         column IPIV(k)."],
     "H"=>
      ["[in,out]", "         H is COMPLEX*16 workspace, dimension (LDH,NB)."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the workspace H. LDH >= max(1,M)."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX*16 workspace, dimension (M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "zlasyf_rk"=>
  {"summary"=>
    ["ZLASYF_RK computes a partial factorization of a complex symmetric",
     "matrix A using the bounded Bunch-Kaufman (rook) diagonal",
     "pivoting method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**T L21**T )  if UPLO = 'L',",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "ZLASYF_RK is an auxiliary routine called by ZSYTRF_RK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,N-KB+1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,1:KB).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "W"=>["[out]", "         W is COMPLEX*16 array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "ssytrs"=>
  {"summary"=>
    ["SSYTRS solves a system of linear equations A*X = B with a real",
     "symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by SSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by SSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sposvx"=>
  {"summary"=>
    ["SPOSVX uses the Cholesky factorization A = U**T*U or A = L*L**T to",
     "compute the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite matrix and X and B",
     "are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "cla_gercond_x"=>
  {"summary"=>
    ["   CLA_GERCOND_X computes the infinity norm condition number of",
     "   op(A) * diag(X) where X is a COMPLEX vector."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by CGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by CGETRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension (N)",
       "    The vector X in the formula op(A) * diag(X)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is REAL array, dimension (N).",
       "    Workspace."]}},
 "dlagts"=>
  {"summary"=>
    ["DLAGTS may be used to solve one of the systems of equations",
     "   (T - lambda*I)*x = y   or   (T - lambda*I)**T*x = y,",
     "where T is an n by n tridiagonal matrix, for x, following the",
     "factorization of (T - lambda*I) as",
     "   (T - lambda*I) = P*L*U ,",
     "by routine DLAGTF. The choice of equation to be solved is",
     "controlled by the argument JOB, and in each case there is an option",
     "to perturb zero or very small diagonal elements of U, this option",
     "being intended for use in applications such as inverse iteration."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is INTEGER",
       "         Specifies the job to be performed by DLAGTS as follows:",
       "         =  1: The equations  (T - lambda*I)x = y  are to be solved,",
       "               but diagonal elements of U are not to be perturbed.",
       "         = -1: The equations  (T - lambda*I)x = y  are to be solved",
       "               and, if overflow would otherwise occur, the diagonal",
       "               elements of U are to be perturbed. See argument TOL",
       "               below.",
       "         =  2: The equations  (T - lambda*I)**Tx = y  are to be solved,",
       "               but diagonal elements of U are not to be perturbed.",
       "         = -2: The equations  (T - lambda*I)**Tx = y  are to be solved",
       "               and, if overflow would otherwise occur, the diagonal",
       "               elements of U are to be perturbed. See argument TOL",
       "               below."],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix T."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (N)",
       "         On entry, A must contain the diagonal elements of U as",
       "         returned from DLAGTF."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, B must contain the first super-diagonal elements of",
       "         U as returned from DLAGTF."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, C must contain the sub-diagonal elements of L as",
       "         returned from DLAGTF."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N-2)",
       "         On entry, D must contain the second super-diagonal elements",
       "         of U as returned from DLAGTF."],
     "IN"=>
      ["[in]",
       "         IN is INTEGER array, dimension (N)",
       "         On entry, IN must contain details of the matrix P as returned",
       "         from DLAGTF."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the right hand side vector y.",
       "         On exit, Y is overwritten by the solution vector x."],
     "TOL"=>
      ["[in,out]",
       "         TOL is DOUBLE PRECISION",
       "         On entry, with  JOB .lt. 0, TOL should be the minimum",
       "         perturbation to be made to very small diagonal elements of U.",
       "         TOL should normally be chosen as about eps*norm(U), where eps",
       "         is the relative machine precision, but if TOL is supplied as",
       "         non-positive, then it is reset to eps*max( abs( u(i,j) ) ).",
       "         If  JOB .gt. 0  then TOL is not referenced.",
       "         On exit, TOL is changed as described above, only if TOL is",
       "         non-positive on entry. Otherwise TOL is unchanged."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0   : successful exit",
       "         .lt. 0: if INFO = -i, the i-th argument had an illegal value",
       "         .gt. 0: overflow would occur when computing the INFO(th)",
       "                 element of the solution vector x. This can only occur",
       "                 when JOB is supplied as positive and either means",
       "                 that a diagonal element of U is very small, or that",
       "                 the elements of the right-hand side vector y are very",
       "                 large."]}},
 "clahef"=>
  {"summary"=>
    ["CLAHEF computes a partial factorization of a complex Hermitian",
     "matrix A using the Bunch-Kaufman diagonal pivoting method. The",
     "partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I      0     )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**H U22**H )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**H L21**H )  if UPLO = 'L'",
     "      ( L21  I ) (  0  A22 ) (  0      I     )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "Note that U**H denotes the conjugate transpose of U.",
     "CLAHEF is an auxiliary routine called by CHETRF. It uses blocked code",
     "(calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or",
     "A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "W"=>["[out]", "         W is COMPLEX array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "sgeesx"=>
  {"summary"=>
    ["SGEESX computes for an N-by-N real nonsymmetric matrix A, the",
     "eigenvalues, the real Schur form T, and, optionally, the matrix of",
     "Schur vectors Z.  This gives the Schur factorization A = Z*T*(Z**T).",
     "Optionally, it also orders the eigenvalues on the diagonal of the",
     "real Schur form so that selected eigenvalues are at the top left;",
     "computes a reciprocal condition number for the average of the",
     "selected eigenvalues (RCONDE); and computes a reciprocal condition",
     "number for the right invariant subspace corresponding to the",
     "selected eigenvalues (RCONDV).  The leading columns of Z form an",
     "orthonormal basis for this invariant subspace.",
     "For further explanation of the reciprocal condition numbers RCONDE",
     "and RCONDV, see Section 4.10 of the LAPACK Users' Guide (where",
     "these quantities are called s and sep respectively).",
     "A real matrix is in real Schur form if it is upper quasi-triangular",
     "with 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in",
     "the form",
     "          [  a  b  ]",
     "          [  c  a  ]",
     "where b*c < 0. The eigenvalues of such a block are a +- sqrt(bc)."],
   "param"=>
    {"JOBVS"=>
      ["[in]",
       "         JOBVS is CHARACTER*1",
       "         = 'N': Schur vectors are not computed;",
       "         = 'V': Schur vectors are computed."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the Schur form.",
       "         = 'N': Eigenvalues are not ordered;",
       "         = 'S': Eigenvalues are ordered (see SELECT)."],
     "SELECT"=>
      ["[in]",
       "         SELECT is a LOGICAL FUNCTION of two REAL arguments",
       "         SELECT must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'S', SELECT is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         If SORT = 'N', SELECT is not referenced.",
       "         An eigenvalue WR(j)+sqrt(-1)*WI(j) is selected if",
       "         SELECT(WR(j),WI(j)) is true; i.e., if either one of a",
       "         complex conjugate pair of eigenvalues is selected, then both",
       "         are.  Note that a selected complex eigenvalue may no longer",
       "         satisfy SELECT(WR(j),WI(j)) = .TRUE. after ordering, since",
       "         ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned); in this",
       "         case INFO may be set to N+3 (see INFO below)."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': None are computed;",
       "         = 'E': Computed for average of selected eigenvalues only;",
       "         = 'V': Computed for selected right invariant subspace only;",
       "         = 'B': Computed for both.",
       "         If SENSE = 'E', 'V' or 'B', SORT must equal 'S'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A is overwritten by its real Schur form T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "                        for which SELECT is true. (Complex conjugate",
       "                        pairs for which SELECT is true for either",
       "                        eigenvalue count as 2.)"],
     "WR"=>["[out]", "         WR is REAL array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is REAL array, dimension (N)",
       "         WR and WI contain the real and imaginary parts, respectively,",
       "         of the computed eigenvalues, in the same order that they",
       "         appear on the diagonal of the output Schur form T.  Complex",
       "         conjugate pairs of eigenvalues appear consecutively with the",
       "         eigenvalue having the positive imaginary part first."],
     "VS"=>
      ["[out]",
       "         VS is REAL array, dimension (LDVS,N)",
       "         If JOBVS = 'V', VS contains the orthogonal matrix Z of Schur",
       "         vectors.",
       "         If JOBVS = 'N', VS is not referenced."],
     "LDVS"=>
      ["[in]",
       "         LDVS is INTEGER",
       "         The leading dimension of the array VS.  LDVS >= 1, and if",
       "         JOBVS = 'V', LDVS >= N."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is REAL",
       "         If SENSE = 'E' or 'B', RCONDE contains the reciprocal",
       "         condition number for the average of the selected eigenvalues.",
       "         Not referenced if SENSE = 'N' or 'V'."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is REAL",
       "         If SENSE = 'V' or 'B', RCONDV contains the reciprocal",
       "         condition number for the selected right invariant subspace.",
       "         Not referenced if SENSE = 'N' or 'E'."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,3*N).",
       "         Also, if SENSE = 'E' or 'V' or 'B',",
       "         LWORK >= N+2*SDIM*(N-SDIM), where SDIM is the number of",
       "         selected eigenvalues computed by this routine.  Note that",
       "         N+2*SDIM*(N-SDIM) <= N+N*N/2. Note also that an error is only",
       "         returned if LWORK < max(1,3*N), but if SENSE = 'E' or 'V' or",
       "         'B' this may not be large enough.",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates upper bounds on the optimal sizes of the",
       "         arrays WORK and IWORK, returns these values as the first",
       "         entries of the WORK and IWORK arrays, and no error messages",
       "         related to LWORK or LIWORK are issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         LIWORK >= 1; if SENSE = 'V' or 'B', LIWORK >= SDIM*(N-SDIM).",
       "         Note that SDIM*(N-SDIM) <= N*N/4. Note also that an error is",
       "         only returned if LIWORK < 1, but if SENSE = 'V' or 'B' this",
       "         may not be large enough.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates upper bounds on the optimal sizes of",
       "         the arrays WORK and IWORK, returns these values as the first",
       "         entries of the WORK and IWORK arrays, and no error messages",
       "         related to LWORK or LIWORK are issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value.",
       "         > 0: if INFO = i, and i is",
       "            <= N: the QR algorithm failed to compute all the",
       "                  eigenvalues; elements 1:ILO-1 and i+1:N of WR and WI",
       "                  contain those eigenvalues which have converged; if",
       "                  JOBVS = 'V', VS contains the transformation which",
       "                  reduces A to its partially converged Schur form.",
       "            = N+1: the eigenvalues could not be reordered because some",
       "                  eigenvalues were too close to separate (the problem",
       "                  is very ill-conditioned);",
       "            = N+2: after reordering, roundoff changed values of some",
       "                  complex eigenvalues so that leading eigenvalues in",
       "                  the Schur form no longer satisfy SELECT=.TRUE.  This",
       "                  could also be caused by underflow due to scaling."]}},
 "ctbcon"=>
  {"summary"=>
    ["CTBCON estimates the reciprocal of the condition number of a",
     "triangular band matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgeequb"=>
  {"summary"=>
    ["DGEEQUB computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most",
     "the radix.",
     "R(i) and C(j) are restricted to be a power of the radix between",
     "SMLNUM = smallest safe number and BIGNUM = largest safe number.  Use",
     "of these scaling factors is not guaranteed to reduce the condition",
     "number of A but works well in practice.",
     "This routine differs from DGEEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled entries' magnitudes are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The M-by-N matrix whose equilibration factors are",
       "         to be computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is DOUBLE PRECISION",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is DOUBLE PRECISION",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "cgghd3"=>
  {"summary"=>
    ["CGGHD3 reduces a pair of complex matrices (A,B) to generalized upper",
     "Hessenberg form using unitary transformations, where A is a",
     "general matrix and B is upper triangular.  The form of the",
     "generalized eigenvalue problem is",
     "   A*x = lambda*B*x,",
     "and B is typically made upper triangular by computing its QR",
     "factorization and moving the unitary matrix Q to the left side",
     "of the equation.",
     "This subroutine simultaneously reduces A to a Hessenberg matrix H:",
     "   Q**H*A*Z = H",
     "and transforms B to another upper triangular matrix T:",
     "   Q**H*B*Z = T",
     "in order to reduce the problem to its standard form",
     "   H*y = lambda*T*y",
     "where y = Z**H*x.",
     "The unitary matrices Q and Z are determined as products of Givens",
     "rotations.  They may either be formed explicitly, or they may be",
     "postmultiplied into input matrices Q1 and Z1, so that",
     "     Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H",
     "     Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H",
     "If Q1 is the unitary matrix from the QR factorization of B in the",
     "original equation A*x = lambda*B*x, then CGGHD3 reduces the original",
     "problem to generalized Hessenberg form.",
     "This is a blocked variant of CGGHRD, using matrix-matrix",
     "multiplications for parts of the computation to enhance performance."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': do not compute Q;",
       "         = 'I': Q is initialized to the unit matrix, and the",
       "                unitary matrix Q is returned;",
       "         = 'V': Q must contain a unitary matrix Q1 on entry,",
       "                and the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': do not compute Z;",
       "         = 'I': Z is initialized to the unit matrix, and the",
       "                unitary matrix Z is returned;",
       "         = 'V': Z must contain a unitary matrix Z1 on entry,",
       "                and the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of A which are to be",
       "         reduced.  It is assumed that A is already upper triangular",
       "         in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are",
       "         normally set by a previous call to CGGBAL; otherwise they",
       "         should be set to 1 and N respectively.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         rest is set to zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the N-by-N upper triangular matrix B.",
       "         On exit, the upper triangular matrix T = Q**H B Z.  The",
       "         elements below the diagonal are set to zero."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the unitary matrix Q1, typically",
       "         from the QR factorization of B.",
       "         On exit, if COMPQ='I', the unitary matrix Q, and if",
       "         COMPQ = 'V', the product Q1*Q.",
       "         Not referenced if COMPQ='N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the unitary matrix Z1.",
       "         On exit, if COMPZ='I', the unitary matrix Z, and if",
       "         COMPZ = 'V', the product Z1*Z.",
       "         Not referenced if COMPZ='N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.",
       "         LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= 1.",
       "         For optimum performance LWORK >= 6*N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dorcsd2by1"=>
  {"summary"=>[],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is computed;",
       "         otherwise:  U1 is not computed."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is computed;",
       "         otherwise:  U2 is not computed."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is computed;",
       "         otherwise:  V1T is not computed."],
     "M"=>
      ["[in]", "         M is INTEGER", "         The number of rows in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is DOUBLE PRECISION array, dimension (LDX11,Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. LDX11 >= MAX(1,P)."],
     "X21"=>
      ["[in,out]",
       "         X21 is DOUBLE PRECISION array, dimension (LDX21,Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "         The leading dimension of X21. LDX21 >= MAX(1,M-P)."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (R), in which R =",
       "         MIN(P,M-P,Q,M-Q).",
       "         C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and",
       "         S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) )."],
     "U1"=>
      ["[out]",
       "         U1 is DOUBLE PRECISION array, dimension (P)",
       "         If JOBU1 = 'Y', U1 contains the P-by-P orthogonal matrix U1."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of U1. If JOBU1 = 'Y', LDU1 >=",
       "         MAX(1,P)."],
     "U2"=>
      ["[out]",
       "         U2 is DOUBLE PRECISION array, dimension (M-P)",
       "         If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) orthogonal",
       "         matrix U2."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of U2. If JOBU2 = 'Y', LDU2 >=",
       "         MAX(1,M-P)."],
     "V1T"=>
      ["[out]",
       "         V1T is DOUBLE PRECISION array, dimension (Q)",
       "         If JOBV1T = 'Y', V1T contains the Q-by-Q matrix orthogonal",
       "         matrix V1**T."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >=",
       "         MAX(1,Q)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK.",
       "         If INFO > 0 on exit, WORK(2:R) contains the values PHI(1),",
       "         ..., PHI(R-1) that, together with THETA(1), ..., THETA(R),",
       "         define the matrix in intermediate bidiagonal-block form",
       "         remaining after nonconvergence. INFO specifies the number",
       "         of nonzero PHI's."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  DBBCSD did not converge. See the description of WORK",
       "               above for details."]}},
 "ctpmqrt"=>
  {"summary"=>
    ["CTPMQRT applies a complex orthogonal matrix Q obtained from a",
     "\"triangular-pentagonal\" complex block reflector H to a general",
     "complex matrix C, which consists of two blocks A and B."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size used for the storage of T.  K >= NB >= 1.",
       "         This must be the same value of NB used to generate T",
       "         in CTPQRT."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CTPQRT in B.  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDV >= max(1,M);",
       "         if SIDE = 'R', LDV >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by CTPQRT, stored as a NB-by-K matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension",
       "         (LDA,N) if SIDE = 'L' or",
       "         (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         Q*C or Q**H*C or C*Q or C*Q**H.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         Q*C or Q**H*C or C*Q or C*Q**H.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array. The dimension of WORK is",
       "          N*NB if SIDE = 'L', or  M*NB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sporfs"=>
  {"summary"=>
    ["SPORFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric positive definite,",
     "and provides error bounds and backward error estimates for the",
     "solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, as computed by SPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by SPOTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cuncsd"=>
  {"summary"=>
    ["CUNCSD computes the CS decomposition of an M-by-M partitioned",
     "unitary matrix X:",
     "                                [  I  0  0 |  0  0  0 ]",
     "                                [  0  C  0 |  0 -S  0 ]",
     "    [ X11 | X12 ]   [ U1 |    ] [  0  0  0 |  0  0 -I ] [ V1 |    ]**H",
     "X = [-----------] = [---------] [---------------------] [---------]   .",
     "    [ X21 | X22 ]   [    | U2 ] [  0  0  0 |  I  0  0 ] [    | V2 ]",
     "                                [  0  S  0 |  0  C  0 ]",
     "                                [  0  0  I |  0  0  0 ]",
     "X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P,",
     "(M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are",
     "R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in",
     "which R = MIN(P,M-P,Q,M-Q)."],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is computed;",
       "         otherwise:  U1 is not computed."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is computed;",
       "         otherwise:  U2 is not computed."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is computed;",
       "         otherwise:  V1T is not computed."],
     "JOBV2T"=>
      ["[in]",
       "         JOBV2T is CHARACTER",
       "         = 'Y':      V2T is computed;",
       "         otherwise:  V2T is not computed."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "SIGNS"=>
      ["[in]",
       "         SIGNS is CHARACTER",
       "         = 'O':      The lower-left block is made nonpositive (the",
       "                     \"other\" convention);",
       "         otherwise:  The upper-right block is made nonpositive (the",
       "                     \"default\" convention)."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11 and X12. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX array, dimension (LDX11,Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. LDX11 >= MAX(1,P)."],
     "X12"=>
      ["[in,out]",
       "         X12 is COMPLEX array, dimension (LDX12,M-Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX12"=>
      ["[in]",
       "         LDX12 is INTEGER",
       "         The leading dimension of X12. LDX12 >= MAX(1,P)."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX array, dimension (LDX21,Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "         The leading dimension of X11. LDX21 >= MAX(1,M-P)."],
     "X22"=>
      ["[in,out]",
       "         X22 is COMPLEX array, dimension (LDX22,M-Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX22"=>
      ["[in]",
       "         LDX22 is INTEGER",
       "         The leading dimension of X11. LDX22 >= MAX(1,M-P)."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (R), in which R =",
       "         MIN(P,M-P,Q,M-Q).",
       "         C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and",
       "         S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) )."],
     "U1"=>
      ["[out]",
       "         U1 is COMPLEX array, dimension (P)",
       "         If JOBU1 = 'Y', U1 contains the P-by-P unitary matrix U1."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of U1. If JOBU1 = 'Y', LDU1 >=",
       "         MAX(1,P)."],
     "U2"=>
      ["[out]",
       "         U2 is COMPLEX array, dimension (M-P)",
       "         If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) unitary",
       "         matrix U2."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of U2. If JOBU2 = 'Y', LDU2 >=",
       "         MAX(1,M-P)."],
     "V1T"=>
      ["[out]",
       "         V1T is COMPLEX array, dimension (Q)",
       "         If JOBV1T = 'Y', V1T contains the Q-by-Q matrix unitary",
       "         matrix V1**H."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >=",
       "         MAX(1,Q)."],
     "V2T"=>
      ["[out]",
       "         V2T is COMPLEX array, dimension (M-Q)",
       "         If JOBV2T = 'Y', V2T contains the (M-Q)-by-(M-Q) unitary",
       "         matrix V2**H."],
     "LDV2T"=>
      ["[in]",
       "         LDV2T is INTEGER",
       "         The leading dimension of V2T. If JOBV2T = 'Y', LDV2T >=",
       "         MAX(1,M-Q)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension MAX(1,LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.",
       "         If INFO > 0 on exit, RWORK(2:R) contains the values PHI(1),",
       "         ..., PHI(R-1) that, together with THETA(1), ..., THETA(R),",
       "         define the matrix in intermediate bidiagonal-block form",
       "         remaining after nonconvergence. INFO specifies the number",
       "         of nonzero PHI's."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If LRWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the RWORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LRWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  CBBCSD did not converge. See the description of RWORK",
       "               above for details."]}},
 "clags2"=>
  {"summary"=>
    ["CLAGS2 computes 2-by-2 unitary matrices U, V and Q, such",
     "that if ( UPPER ) then",
     "          U**H *A*Q = U**H *( A1 A2 )*Q = ( x  0  )",
     "                            ( 0  A3 )     ( x  x  )",
     "and",
     "          V**H*B*Q = V**H *( B1 B2 )*Q = ( x  0  )",
     "                           ( 0  B3 )     ( x  x  )",
     "or if ( .NOT.UPPER ) then",
     "          U**H *A*Q = U**H *( A1 0  )*Q = ( x  x  )",
     "                            ( A2 A3 )     ( 0  x  )",
     "and",
     "          V**H *B*Q = V**H *( B1 0  )*Q = ( x  x  )",
     "                            ( B2 B3 )     ( 0  x  )",
     "where",
     "  U = (   CSU    SNU ), V = (  CSV    SNV ),",
     "      ( -SNU**H  CSU )      ( -SNV**H CSV )",
     "  Q = (   CSQ    SNQ )",
     "      ( -SNQ**H  CSQ )",
     "The rows of the transformed A and B are parallel. Moreover, if the",
     "input 2-by-2 matrix A is not zero, then the transformed (1,1) entry",
     "of A is not zero. If the input matrices A and B are both not zero,",
     "then the transformed (2,2) element of B is not zero, except when the",
     "first rows of input A and B are parallel and the second rows are",
     "zero."],
   "param"=>
    {"UPPER"=>
      ["[in]",
       "         UPPER is LOGICAL",
       "         = .TRUE.: the input matrices A and B are upper triangular.",
       "         = .FALSE.: the input matrices A and B are lower triangular."],
     "A1"=>["[in]", "         A1 is REAL"],
     "A2"=>["[in]", "         A2 is COMPLEX"],
     "A3"=>
      ["[in]",
       "         A3 is REAL",
       "         On entry, A1, A2 and A3 are elements of the input 2-by-2",
       "         upper (lower) triangular matrix A."],
     "B1"=>["[in]", "         B1 is REAL"],
     "B2"=>["[in]", "         B2 is COMPLEX"],
     "B3"=>
      ["[in]",
       "         B3 is REAL",
       "         On entry, B1, B2 and B3 are elements of the input 2-by-2",
       "         upper (lower) triangular matrix B."],
     "CSU"=>["[out]", "         CSU is REAL"],
     "SNU"=>
      ["[out]",
       "         SNU is COMPLEX",
       "         The desired unitary matrix U."],
     "CSV"=>["[out]", "         CSV is REAL"],
     "SNV"=>
      ["[out]",
       "         SNV is COMPLEX",
       "         The desired unitary matrix V."],
     "CSQ"=>["[out]", "         CSQ is REAL"],
     "SNQ"=>
      ["[out]",
       "         SNQ is COMPLEX",
       "         The desired unitary matrix Q."]}},
 "sgecon"=>
  {"summary"=>
    ["SGECON estimates the reciprocal of the condition number of a general",
     "real matrix A, in either the 1-norm or the infinity-norm, using",
     "the LU factorization computed by SGETRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by SGETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dpotrs"=>
  {"summary"=>
    ["DPOTRS solves a system of linear equations A*X = B with a symmetric",
     "positive definite matrix A using the Cholesky factorization",
     "A = U**T*U or A = L*L**T computed by DPOTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, as computed by DPOTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "stplqt"=>
  {"summary"=>
    ["DTPLQT computes a blocked LQ factorization of a real",
     "\"triangular-pentagonal\" matrix C, which is composed of a",
     "triangular block A and pentagonal block B, using the compact",
     "WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B, and the order of the",
       "         triangular matrix A.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the lower trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.  M >= MB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the lower triangular N-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the lower triangular matrix L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first N-L columns",
       "         are rectangular, and the last L columns are lower trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,N)",
       "         The lower triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (MB*M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zunmlq"=>
  {"summary"=>
    ["ZUNMLQ overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k)**H . . . H(2)**H H(1)**H",
     "as returned by ZGELQF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         ZGELQF in the first k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGELQF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zptsv"=>
  {"summary"=>
    ["ZPTSV computes the solution to a complex system of linear equations",
     "A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal",
     "matrix, and X and B are N-by-NRHS matrices.",
     "A is factored as A = L*D*L**H, and the factored form of A is then",
     "used to solve the system of equations."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.  On exit, the n diagonal elements of the diagonal matrix",
       "         D from the factorization A = L*D*L**H."],
     "E"=>
      ["[in,out]",
       "         E is COMPLEX*16 array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A.  On exit, the (n-1) subdiagonal elements of the",
       "         unit bidiagonal factor L from the L*D*L**H factorization of",
       "         A.  E can also be regarded as the superdiagonal of the unit",
       "         bidiagonal factor U from the U**H*D*U factorization of A."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the solution has not been",
       "               computed.  The factorization has not been completed",
       "               unless i = N."]}},
 "dsytri2"=>
  {"summary"=>
    ["DSYTRI2 computes the inverse of a DOUBLE PRECISION symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "DSYTRF. DSYTRI2 sets the LEADING DIMENSION of the workspace",
     "before calling DSYTRI2X that actually computes the inverse."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by DSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NB structure of D",
       "         as determined by DSYTRF."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (N+NB+1)*(NB+3)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         WORK is size >= (N+NB+1)*(NB+3)",
       "         If LDWORK = -1, then a workspace query is assumed; the routine",
       "          calculates:",
       "             - the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array,",
       "             - and no error message related to LDWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "slaqge"=>
  {"summary"=>
    ["SLAQGE equilibrates a general M by N matrix A using the row and",
     "column scaling factors in the vectors R and C."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M by N matrix A.",
       "         On exit, the equilibrated matrix.  See EQUED for the form of",
       "         the equilibrated matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "R"=>
      ["[in]",
       "         R is REAL array, dimension (M)",
       "         The row scale factors for A."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "         The column scale factors for A."],
     "ROWCND"=>
      ["[in]",
       "         ROWCND is REAL",
       "         Ratio of the smallest R(i) to the largest R(i)."],
     "COLCND"=>
      ["[in]",
       "         COLCND is REAL",
       "         Ratio of the smallest C(i) to the largest C(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies the form of equilibration that was done.",
       "         = 'N':  No equilibration",
       "         = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "                 diag(R).",
       "         = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "                 by diag(C).",
       "         = 'B':  Both row and column equilibration, i.e., A has been",
       "                 replaced by diag(R) * A * diag(C)."]}},
 "chptrf"=>
  {"summary"=>
    ["CHPTRF computes the factorization of a complex Hermitian packed",
     "matrix A using the Bunch-Kaufman diagonal pivoting method:",
     "   A = U*D*U**H  or  A = L*D*L**H",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is Hermitian and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L, stored as a packed triangular",
       "         matrix overwriting A (see below for further details)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "slamswlq"=>
  {"summary"=>
    ["   DLAMQRTS overwrites the general real M-by-N matrix C with",
     "                   SIDE = 'L'     SIDE = 'R'",
     "   TRANS = 'N':      Q * C          C * Q",
     "   TRANS = 'T':      Q**T * C       C * Q**T",
     "   where Q is a real orthogonal matrix defined as the product of blocked",
     "   elementary reflectors computed by short wide LQ",
     "   factorization (DLASWLQ)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         M >= K >= 0;"],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         M >= MB >= 1"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.",
       "               MB > M."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,K)",
       "         The i-th row must contain the vector which defines the blocked",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DLASWLQ in the first k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension",
       "         ( M * Number of blocks(CEIL(N-K/NB-K)),",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]", "        (workspace) REAL array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,NB) * MB;",
       "         if SIDE = 'R', LWORK >= max(1,M) * MB.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "stfttp"=>
  {"summary"=>
    ["STFTTP copies a triangular matrix A from rectangular full packed",
     "format (TF) to standard packed format (TP)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF is in Normal format;",
       "         = 'T':  ARF is in Transpose format;"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "ARF"=>
      ["[in]",
       "         ARF is REAL array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "AP"=>
      ["[out]",
       "         AP is REAL array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clalsd"=>
  {"summary"=>
    ["CLALSD uses the singular value decomposition of A to solve the least",
     "squares problem of finding X to minimize the Euclidean norm of each",
     "column of A*X-B, where A is N-by-N upper bidiagonal, and X and B",
     "are N-by-NRHS. The solution X overwrites B.",
     "The singular values of A smaller than RCOND times the largest",
     "singular value are treated as zero in solving the least squares",
     "problem; in this case a minimum norm solution is returned.",
     "The actual singular values are returned in D in ascending order.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "        = 'U': D and E define an upper bidiagonal matrix.",
       "        = 'L': D and E define a  lower bidiagonal matrix."],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        The maximum size of the subproblems at the bottom of the",
       "        computation tree."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the  bidiagonal matrix.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B. NRHS must be at least 1."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry D contains the main diagonal of the bidiagonal",
       "        matrix. On exit, if INFO = 0, D contains its singular values."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "        Contains the super-diagonal entries of the bidiagonal matrix.",
       "        On exit, E has been destroyed."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "        On input, B contains the right hand sides of the least",
       "        squares problem. On output, B contains the solution X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B in the calling subprogram.",
       "        LDB must be at least max(1,N)."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "        The singular values of A less than or equal to RCOND times",
       "        the largest singular value are treated as zero in solving",
       "        the least squares problem. If RCOND is negative,",
       "        machine precision is used instead.",
       "        For example, if diag(S)*X=B were the least squares problem,",
       "        where diag(S) is a diagonal matrix of singular values, the",
       "        solution would be X(i) = B(i) / S(i) if S(i) is greater than",
       "        RCOND*max(S), and X(i) = 0 if S(i) is less than or equal to",
       "        RCOND*max(S)."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "        The number of singular values of A greater than RCOND times",
       "        the largest singular value."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX array, dimension (N * NRHS)."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension at least",
       "        (9*N + 2*N*SMLSIZ + 8*N*NLVL + 3*SMLSIZ*NRHS +",
       "        MAX( (SMLSIZ+1)**2, N*(1+NRHS) + 2*NRHS ),",
       "        where",
       "        NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 )"],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (3*N*NLVL + 11*N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit.",
       "        < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "        > 0:  The algorithm failed to compute a singular value while",
       "              working on the submatrix lying in rows and columns",
       "              INFO/(N+1) through MOD(INFO,N+1)."]}},
 "slaqr5"=>
  {"summary"=>
    ["   SLAQR5, called by SLAQR0, performs a",
     "   single small-bulge multi-shift QR sweep."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is logical scalar",
       "            WANTT = .true. if the quasi-triangular Schur factor",
       "            is being computed.  WANTT is set to .false. otherwise."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is logical scalar",
       "            WANTZ = .true. if the orthogonal Schur factor is being",
       "            computed.  WANTZ is set to .false. otherwise."],
     "KACC22"=>
      ["[in]",
       "         KACC22 is integer with value 0, 1, or 2.",
       "            Specifies the computation mode of far-from-diagonal",
       "            orthogonal updates.",
       "       = 0: SLAQR5 does not accumulate reflections and does not",
       "            use matrix-matrix multiply to update far-from-diagonal",
       "            matrix entries.",
       "       = 1: SLAQR5 accumulates reflections and uses matrix-matrix",
       "            multiply to update the far-from-diagonal matrix entries.",
       "       = 2: SLAQR5 accumulates reflections, uses matrix-matrix",
       "            multiply to update the far-from-diagonal matrix entries,",
       "            and takes advantage of 2-by-2 block structure during",
       "            matrix multiplies."],
     "N"=>
      ["[in]",
       "         N is integer scalar",
       "            N is the order of the Hessenberg matrix H upon which this",
       "            subroutine operates."],
     "KTOP"=>["[in]", "         KTOP is integer scalar"],
     "KBOT"=>
      ["[in]",
       "         KBOT is integer scalar",
       "            These are the first and last rows and columns of an",
       "            isolated diagonal block upon which the QR sweep is to be",
       "            applied. It is assumed without a check that",
       "                      either KTOP = 1  or   H(KTOP,KTOP-1) = 0",
       "            and",
       "                      either KBOT = N  or   H(KBOT+1,KBOT) = 0."],
     "NSHFTS"=>
      ["[in]",
       "         NSHFTS is integer scalar",
       "            NSHFTS gives the number of simultaneous shifts.  NSHFTS",
       "            must be positive and even."],
     "SR"=>["[in,out]", "         SR is REAL array of size (NSHFTS)"],
     "SI"=>
      ["[in,out]",
       "         SI is REAL array of size (NSHFTS)",
       "            SR contains the real parts and SI contains the imaginary",
       "            parts of the NSHFTS shifts of origin that define the",
       "            multi-shift QR sweep.  On output SR and SI may be",
       "            reordered."],
     "H"=>
      ["[in,out]",
       "         H is REAL array of size (LDH,N)",
       "            On input H contains a Hessenberg matrix.  On output a",
       "            multi-shift QR sweep with shifts SR(J)+i*SI(J) is applied",
       "            to the isolated diagonal block in rows and columns KTOP",
       "            through KBOT."],
     "LDH"=>
      ["[in]",
       "         LDH is integer scalar",
       "            LDH is the leading dimension of H just as declared in the",
       "            calling procedure.  LDH.GE.MAX(1,N)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "            Specify the rows of Z to which transformations must be",
       "            applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N"],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array of size (LDZ,IHIZ)",
       "            If WANTZ = .TRUE., then the QR Sweep orthogonal",
       "            similarity transformation is accumulated into",
       "            Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "            If WANTZ = .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer scalar",
       "            LDA is the leading dimension of Z just as declared in",
       "            the calling procedure. LDZ.GE.N."],
     "V"=>["[out]", "         V is REAL array of size (LDV,NSHFTS/2)"],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "            LDV is the leading dimension of V as declared in the",
       "            calling procedure.  LDV.GE.3."],
     "U"=>
      ["[out]",
       "         U is REAL array of size",
       "            (LDU,3*NSHFTS-3)"],
     "LDU"=>
      ["[in]",
       "         LDU is integer scalar",
       "            LDU is the leading dimension of U just as declared in the",
       "            in the calling subroutine.  LDU.GE.3*NSHFTS-3."],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "            NH is the number of columns in array WH available for",
       "            workspace. NH.GE.1."],
     "WH"=>["[out]", "         WH is REAL array of size (LDWH,NH)"],
     "LDWH"=>
      ["[in]",
       "         LDWH is integer scalar",
       "            Leading dimension of WH just as declared in the",
       "            calling procedure.  LDWH.GE.3*NSHFTS-3."],
     "NV"=>
      ["[in]",
       "         NV is integer scalar",
       "            NV is the number of rows in WV agailable for workspace.",
       "            NV.GE.1."],
     "WV"=>
      ["[out]",
       "         WV is REAL array of size",
       "            (LDWV,3*NSHFTS-3)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer scalar",
       "            LDWV is the leading dimension of WV as declared in the",
       "            in the calling subroutine.  LDWV.GE.NV."]}},
 "dlasq6"=>
  {"summary"=>
    ["DLASQ6 computes one dqd (shift equal to zero) transform in",
     "ping-pong form, with protection against underflow and overflow."],
   "param"=>
    {"I0"=>["[in]", "         I0 is INTEGER", "       First index."],
     "N0"=>["[in]", "         N0 is INTEGER", "       Last index."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension ( 4*N )",
       "       Z holds the qd array. EMIN is stored in Z(4*N0) to avoid",
       "       an extra argument."],
     "PP"=>
      ["[in]",
       "         PP is INTEGER",
       "       PP=0 for ping, PP=1 for pong."],
     "DMIN"=>
      ["[out]",
       "         DMIN is DOUBLE PRECISION",
       "       Minimum value of d."],
     "DMIN1"=>
      ["[out]",
       "         DMIN1 is DOUBLE PRECISION",
       "       Minimum value of d, excluding D( N0 )."],
     "DMIN2"=>
      ["[out]",
       "         DMIN2 is DOUBLE PRECISION",
       "       Minimum value of d, excluding D( N0 ) and D( N0-1 )."],
     "DN"=>
      ["[out]",
       "         DN is DOUBLE PRECISION",
       "       d(N0), the last value of d."],
     "DNM1"=>["[out]", "         DNM1 is DOUBLE PRECISION", "       d(N0-1)."],
     "DNM2"=>
      ["[out]", "         DNM2 is DOUBLE PRECISION", "       d(N0-2)."]}},
 "claed0"=>
  {"summary"=>
    ["Using the divide and conquer method, CLAED0 computes all eigenvalues",
     "of a symmetric tridiagonal matrix which is one diagonal block of",
     "those from reducing a dense or band Hermitian matrix and",
     "corresponding eigenvectors of the dense or band matrix."],
   "param"=>
    {"QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the unitary matrix used to reduce",
       "        the full matrix to tridiagonal form.  QSIZ >= N if ICOMPQ = 1."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry, the diagonal elements of the tridiagonal matrix.",
       "        On exit, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "        On entry, the off-diagonal elements of the tridiagonal matrix.",
       "        On exit, E has been destroyed."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDQ,N)",
       "        On entry, Q must contain an QSIZ x N matrix whose columns",
       "        unitarily orthonormal. It is a part of the unitary matrix",
       "        that reduces the full dense Hermitian matrix to a",
       "        (reducible) symmetric tridiagonal matrix."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array,",
       "        the dimension of IWORK must be at least",
       "                     6 + 6*N + 5*N*lg N",
       "                     ( lg( N ) = smallest integer k",
       "                                 such that 2^k >= N )"],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array,",
       "                              dimension (1 + 3*N + 2*N*lg N + 3*N**2)",
       "                       ( lg( N ) = smallest integer k",
       "                                   such that 2^k >= N )"],
     "QSTORE"=>
      ["[out]",
       "         QSTORE is COMPLEX array, dimension (LDQS, N)",
       "        Used to store parts of",
       "        the eigenvector matrix when the updating matrix multiplies",
       "        take place."],
     "LDQS"=>
      ["[in]",
       "         LDQS is INTEGER",
       "        The leading dimension of the array QSTORE.",
       "        LDQS >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The algorithm failed to compute an eigenvalue while",
       "               working on the submatrix lying in rows and columns",
       "               INFO/(N+1) through mod(INFO,N+1)."]}},
 "zhetrs2"=>
  {"summary"=>
    ["ZHETRS2 solves a system of linear equations A*X = B with a complex",
     "Hermitian matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by ZHETRF and converted by ZSYCONV."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZHETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHETRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhbgv"=>
  {"summary"=>
    ["ZHBGV computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite banded eigenproblem, of",
     "the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian",
     "and banded, and B is also positive definite."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is COMPLEX*16 array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(kb+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**H*S, as returned by ZPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i). The eigenvectors are",
       "         normalized so that Z**H*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= N."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is:",
       "            <= N:  the algorithm failed to converge:",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then ZPBSTF",
       "                   returned INFO = i: B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "sgelsd"=>
  {"summary"=>
    ["SGELSD computes the minimum-norm solution to a real linear least",
     "squares problem:",
     "    minimize 2-norm(| b - A*x |)",
     "using the singular value decomposition (SVD) of A. A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X.",
     "The problem is solved in three steps:",
     "(1) Reduce the coefficient matrix A to bidiagonal form with",
     "    Householder transformations, reducing the original problem",
     "    into a \"bidiagonal least squares problem\" (BLS)",
     "(2) Solve the BLS using a divide and conquer approach.",
     "(3) Apply back all the Householder transformations to solve",
     "    the original least squares problem.",
     "The effective rank of A is determined by treating as zero those",
     "singular values which are less than RCOND times the largest singular",
     "value.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of A. N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A has been destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, B is overwritten by the N-by-NRHS solution",
       "         matrix X.  If m >= n and RANK = n, the residual",
       "         sum-of-squares for the solution in the i-th column is given",
       "         by the sum of squares of elements n+1:m in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,max(M,N))."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (min(M,N))",
       "         The singular values of A in decreasing order.",
       "         The condition number of A in the 2-norm = S(1)/S(min(m,n))."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "         RCOND is used to determine the effective rank of A.",
       "         Singular values S(i) <= RCOND*S(1) are treated as zero.",
       "         If RCOND < 0, machine precision is used instead."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the number of singular values",
       "         which are greater than RCOND*S(1)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK must be at least 1.",
       "         The exact minimum amount of workspace needed depends on M,",
       "         N and NRHS. As long as LWORK is at least",
       "             12*N + 2*N*SMLSIZ + 8*N*NLVL + N*NRHS + (SMLSIZ+1)**2,",
       "         if M is greater than or equal to N or",
       "             12*M + 2*M*SMLSIZ + 8*M*NLVL + M*NRHS + (SMLSIZ+1)**2,",
       "         if M is less than N, the code will execute correctly.",
       "         SMLSIZ is returned by ILAENV and is equal to the maximum",
       "         size of the subproblems at the bottom of the computation",
       "         tree (usually about 25), and",
       "            NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 )",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the array WORK and the",
       "         minimum size of the array IWORK, and returns these values as",
       "         the first entries of the WORK and IWORK arrays, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         LIWORK >= max(1, 3*MINMN*NLVL + 11*MINMN),",
       "         where MINMN = MIN( M,N ).",
       "         On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  the algorithm for computing the SVD failed to converge;",
       "               if INFO = i, i off-diagonal elements of an intermediate",
       "               bidiagonal form did not converge to zero."]}},
 "sla_gbamv"=>
  {"summary"=>
    ["SLA_GBAMV  performs one of the matrix-vector operations",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "   or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "m by n matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is INTEGER",
       "          On entry, TRANS specifies the operation to be performed as",
       "          follows:",
       "            BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)",
       "            BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "            BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of the matrix A.",
       "          M must be at least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "          The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "          The number of superdiagonals within the band of A.  KU >= 0."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "AB"=>
      ["[in]",
       "         AB is REAL array of DIMENSION ( LDAB, n )",
       "          Before entry, the leading m by n part of the array AB must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "          On entry, LDA specifies the first dimension of AB as declared",
       "          in the calling (sub) program. LDAB must be at least",
       "          max( 1, m ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is REAL array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension",
       "          ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit.",
       " Level 2 Blas routine."]}},
 "slasd4"=>
  {"summary"=>
    ["This subroutine computes the square root of the I-th updated",
     "eigenvalue of a positive symmetric rank-one modification to",
     "a positive diagonal matrix whose entries are given as the squares",
     "of the corresponding entries in the array d, and that",
     "       0 <= D(i) < D(j)  for  i < j",
     "and that RHO > 0. This is arranged by the calling routine, and is",
     "no loss in generality.  The rank-one modified system is thus",
     "       diag( D ) * diag( D ) +  RHO * Z * Z_transpose.",
     "where we assume the Euclidean norm of Z is 1.",
     "The method consists of approximating the rational functions in the",
     "secular equation by simpler interpolating rational functions."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "        The length of all arrays."],
     "I"=>
      ["[in]",
       "         I is INTEGER",
       "        The index of the eigenvalue to be computed.  1 <= I <= N."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension ( N )",
       "        The original eigenvalues.  It is assumed that they are in",
       "        order, 0 <= D(I) < D(J)  for I < J."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension ( N )",
       "        The components of the updating vector."],
     "DELTA"=>
      ["[out]",
       "         DELTA is REAL array, dimension ( N )",
       "        If N .ne. 1, DELTA contains (D(j) - sigma_I) in its  j-th",
       "        component.  If N = 1, then DELTA(1) = 1.  The vector DELTA",
       "        contains the information necessary to construct the",
       "        (singular) eigenvectors."],
     "RHO"=>
      ["[in]",
       "         RHO is REAL",
       "        The scalar in the symmetric updating formula."],
     "SIGMA"=>
      ["[out]",
       "         SIGMA is REAL",
       "        The computed sigma_I, the I-th updated eigenvalue."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension ( N )",
       "        If N .ne. 1, WORK contains (D(j) + sigma_I) in its  j-th",
       "        component.  If N = 1, then WORK( 1 ) = 1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit",
       "        > 0:  if INFO = 1, the updating process failed."]}},
 "dtptrs"=>
  {"summary"=>
    ["DTPTRS solves a triangular system of the form",
     "   A * X = B  or  A**T * X = B,",
     "where A is a triangular matrix of order N stored in packed format,",
     "and B is an N-by-NRHS matrix.  A check is made to verify that A is",
     "nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element of A is zero,",
       "               indicating that the matrix is singular and the",
       "               solutions X have not been computed."]}},
 "sgglse"=>
  {"summary"=>
    ["SGGLSE solves the linear equality-constrained least squares (LSE)",
     "problem:",
     "        minimize || c - A*x ||_2   subject to   B*x = d",
     "where A is an M-by-N matrix, B is a P-by-N matrix, c is a given",
     "M-vector, and d is a given P-vector. It is assumed that",
     "P <= N <= M+P, and",
     "         rank(B) = P and  rank( (A) ) = N.",
     "                              ( (B) )",
     "These conditions ensure that the LSE problem has a unique solution,",
     "which is obtained using a generalized RQ factorization of the",
     "matrices (B, A) given by",
     "   B = (0 R)*Q,   A = Z*T*Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B. N >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B. 0 <= P <= N <= M+P."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, the upper triangle of the subarray B(1:P,N-P+1:N)",
       "         contains the P-by-P upper triangular matrix R."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (M)",
       "         On entry, C contains the right hand side vector for the",
       "         least squares part of the LSE problem.",
       "         On exit, the residual sum of squares for the solution",
       "         is given by the sum of squares of elements N-P+1 to M of",
       "         vector C."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (P)",
       "         On entry, D contains the right hand side vector for the",
       "         constrained equation.",
       "         On exit, D is destroyed."],
     "X"=>
      ["[out]",
       "         X is REAL array, dimension (N)",
       "         On exit, X is the solution of the LSE problem."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M+N+P).",
       "         For optimum performance LWORK >= P+min(M,N)+max(M,N)*NB,",
       "         where NB is an upper bound for the optimal blocksizes for",
       "         SGEQRF, SGERQF, SORMQR and SORMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the upper triangular factor R associated with B in the",
       "               generalized RQ factorization of the pair (B, A) is",
       "               singular, so that rank(B) < P; the least squares",
       "               solution could not be computed.",
       "         = 2:  the (N-P) by (N-P) part of the upper trapezoidal factor",
       "               T associated with A in the generalized RQ factorization",
       "               of the pair (B, A) is singular, so that",
       "               rank( (A) ) < N; the least squares solution could not",
       "                   ( (B) )",
       "               be computed."]}},
 "dla_gbrcond"=>
  {"summary"=>
    ["   DLA_GBRCOND Estimates the Skeel condition number of  op(A) * op2(C)",
     "   where op2 is determined by CMODE as follows",
     "   CMODE =  1    op2(C) = C",
     "   CMODE =  0    op2(C) = I",
     "   CMODE = -1    op2(C) = inv(C)",
     "   The Skeel condition number  cond(A) = norminf( |inv(A)||A| )",
     "   is computed by computing scaling factors R such that",
     "   diag(R)*A*op2(C) is row equilibrated and computing the standard",
     "   infinity-norm condition number."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "    On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is DOUBLE PRECISION array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by DGBTRF.  U is stored as an upper triangular",
       "    band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1,",
       "    and the multipliers used during the factorization are stored",
       "    in rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by DGBTRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "CMODE"=>
      ["[in]",
       "         CMODE is INTEGER",
       "    Determines op2(C) in the formula op(A) * op2(C) as follows:",
       "    CMODE =  1    op2(C) = C",
       "    CMODE =  0    op2(C) = I",
       "    CMODE = -1    op2(C) = inv(C)"],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The vector C in the formula op(A) * op2(C)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is DOUBLE PRECISION array, dimension (5*N).",
       "    Workspace."],
     "IWORK"=>
      ["[in]",
       "         IWORK is INTEGER array, dimension (N).",
       "    Workspace."]}},
 "slasd3"=>
  {"summary"=>
    ["SLASD3 finds all the square roots of the roots of the secular",
     "equation, as defined by the values in D and Z.  It makes the",
     "appropriate calls to SLASD4 and then updates the singular",
     "vectors by matrix multiplication.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none.",
     "SLASD3 is called from SLASD1."],
   "param"=>
    {"NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block.  NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block.  NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has N = NL + NR + 1 rows and",
       "        M = N + SQRE >= N columns."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "        The size of the secular equation, 1 =< K = < N."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension(K)",
       "        On exit the square roots of the roots of the secular equation,",
       "        in ascending order."],
     "Q"=>
      ["[out]",
       "         Q is REAL array,",
       "                    dimension at least (LDQ,K)."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= K."],
     "DSIGMA"=>
      ["[in,out]",
       "         DSIGMA is REAL array, dimension(K)",
       "        The first K elements of this array contain the old roots",
       "        of the deflated updating problem.  These are the poles",
       "        of the secular equation."],
     "U"=>
      ["[out]",
       "         U is REAL array, dimension (LDU, N)",
       "        The last N - K columns of this matrix contain the deflated",
       "        left singular vectors."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "        The leading dimension of the array U.  LDU >= N."],
     "U2"=>
      ["[in]",
       "         U2 is REAL array, dimension (LDU2, N)",
       "        The first K columns of this matrix contain the non-deflated",
       "        left singular vectors for the split problem."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "        The leading dimension of the array U2.  LDU2 >= N."],
     "VT"=>
      ["[out]",
       "         VT is REAL array, dimension (LDVT, M)",
       "        The last M - K columns of VT**T contain the deflated",
       "        right singular vectors."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "        The leading dimension of the array VT.  LDVT >= N."],
     "VT2"=>
      ["[in,out]",
       "         VT2 is REAL array, dimension (LDVT2, N)",
       "        The first K columns of VT2**T contain the non-deflated",
       "        right singular vectors for the split problem."],
     "LDVT2"=>
      ["[in]",
       "         LDVT2 is INTEGER",
       "        The leading dimension of the array VT2.  LDVT2 >= N."],
     "IDXC"=>
      ["[in]",
       "         IDXC is INTEGER array, dimension (N)",
       "        The permutation used to arrange the columns of U (and rows of",
       "        VT) into three groups:  the first group contains non-zero",
       "        entries only at and above (or before) NL +1; the second",
       "        contains non-zero entries only at and below (or after) NL+2;",
       "        and the third is dense. The first column of U and the row of",
       "        VT are treated separately, however.",
       "        The rows of the singular vectors found by SLASD4",
       "        must be likewise permuted before the matrix multiplies can",
       "        take place."],
     "CTOT"=>
      ["[in]",
       "         CTOT is INTEGER array, dimension (4)",
       "        A count of the total number of the various types of columns",
       "        in U (or rows in VT), as described in IDXC. The fourth column",
       "        type is any column which has been deflated."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (K)",
       "        The first K elements of this array contain the components",
       "        of the deflation-adjusted updating row vector."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit.",
       "        < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "        > 0:  if INFO = 1, a singular value did not converge"]}},
 "sorgbr"=>
  {"summary"=>
    ["SORGBR generates one of the real orthogonal matrices Q or P**T",
     "determined by SGEBRD when reducing a real matrix A to bidiagonal",
     "form: A = Q * B * P**T.  Q and P**T are defined as products of",
     "elementary reflectors H(i) or G(i) respectively.",
     "If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q",
     "is of order M:",
     "if m >= k, Q = H(1) H(2) . . . H(k) and SORGBR returns the first n",
     "columns of Q, where m >= n >= k;",
     "if m < k, Q = H(1) H(2) . . . H(m-1) and SORGBR returns Q as an",
     "M-by-M matrix.",
     "If VECT = 'P', A is assumed to have been a K-by-N matrix, and P**T",
     "is of order N:",
     "if k < n, P**T = G(k) . . . G(2) G(1) and SORGBR returns the first m",
     "rows of P**T, where n >= m >= k;",
     "if k >= n, P**T = G(n-1) . . . G(2) G(1) and SORGBR returns P**T as",
     "an N-by-N matrix."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         Specifies whether the matrix Q or the matrix P**T is",
       "         required, as defined in the transformation applied by SGEBRD:",
       "         = 'Q':  generate Q;",
       "         = 'P':  generate P**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q or P**T to be returned.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q or P**T to be returned.",
       "         N >= 0.",
       "         If VECT = 'Q', M >= N >= min(M,K);",
       "         if VECT = 'P', N >= M >= min(N,K)."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         If VECT = 'Q', the number of columns in the original M-by-K",
       "         matrix reduced by SGEBRD.",
       "         If VECT = 'P', the number of rows in the original K-by-N",
       "         matrix reduced by SGEBRD.",
       "         K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by SGEBRD.",
       "         On exit, the M-by-N matrix Q or P**T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension",
       "                               (min(M,K)) if VECT = 'Q'",
       "                               (min(N,K)) if VECT = 'P'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i) or G(i), which determines Q or P**T, as",
       "         returned by SGEBRD in its array argument TAUQ or TAUP."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,min(M,N)).",
       "         For optimum performance LWORK >= min(M,N)*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaneg"=>
  {"summary"=>
    ["DLANEG computes the Sturm count, the number of negative pivots",
     "encountered while factoring tridiagonal T - sigma I = L D L^T.",
     "This implementation works directly on the factors without forming",
     "the tridiagonal matrix T.  The Sturm count is also the number of",
     "eigenvalues of T less than sigma.",
     "This routine is called from DLARRB.",
     "The current routine does not use the PIVMIN parameter but rather",
     "requires IEEE-754 propagation of Infinities and NaNs.  This",
     "routine also has no input range restrictions but does require",
     "default exception handling such that x/0 produces Inf when x is",
     "non-zero, and Inf/Inf produces NaN.  For more information, see:",
     "  Marques, Riedy, and Voemel, \"Benefits of IEEE-754 Features in",
     "  Modern Symmetric Tridiagonal Eigensolvers,\" SIAM Journal on",
     "  Scientific Computing, v28, n5, 2006.  DOI 10.1137/050641624",
     "  (Tech report version in LAWN 172 with the same title.)"],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The N diagonal elements of the diagonal matrix D."],
     "LLD"=>
      ["[in]",
       "         LLD is DOUBLE PRECISION array, dimension (N-1)",
       "         The (N-1) elements L(i)*L(i)*D(i)."],
     "SIGMA"=>
      ["[in]",
       "         SIGMA is DOUBLE PRECISION",
       "         Shift amount in T - sigma I = L D L^T."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "         The minimum pivot in the Sturm sequence.  May be used",
       "         when zero pivots are encountered on non-IEEE-754",
       "         architectures."],
     "R"=>
      ["[in]",
       "         R is INTEGER",
       "         The twist index for the twisted factorization that is used",
       "         for the negcount."]}},
 "dlantb"=>
  {"summary"=>
    ["DLANTB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n triangular band matrix A,  with ( k + 1 ) diagonals.",
     "   DLANTB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANTB as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, DLANTB is",
       "         set to zero."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals of the matrix A if UPLO = 'L'.",
       "         K >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first k+1 rows of AB.  The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)   = A(i,j) for j<=i<=min(n,j+k).",
       "         Note that when DIAG = 'U', the elements of the array AB",
       "         corresponding to the diagonal elements of the matrix A are",
       "         not referenced, but are assumed to be one."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= K+1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "zlasyf"=>
  {"summary"=>
    ["ZLASYF computes a partial factorization of a complex symmetric matrix",
     "A using the Bunch-Kaufman diagonal pivoting method. The partial",
     "factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) ( D    0  ) ( L11**T L21**T )  if UPLO = 'L'",
     "      ( L21  I ) ( 0   A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "Note that U**T denotes the transpose of U.",
     "ZLASYF is an auxiliary routine called by ZSYTRF. It uses blocked code",
     "(calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or",
     "A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "W"=>["[out]", "         W is COMPLEX*16 array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "dsycon"=>
  {"summary"=>
    ["DSYCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric matrix A using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by DSYTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by DSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgeequ"=>
  {"summary"=>
    ["SGEEQU computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.",
     "R(i) and C(j) are restricted to be between SMLNUM = smallest safe",
     "number and BIGNUM = largest safe number.  Use of these scaling",
     "factors is not guaranteed to reduce the condition number of A but",
     "works well in practice."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The M-by-N matrix whose equilibration factors are",
       "         to be computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is REAL array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is REAL array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is REAL",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is REAL",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "zunmrq"=>
  {"summary"=>
    ["ZUNMRQ overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1)**H H(2)**H . . . H(k)**H",
     "as returned by ZGERQF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         ZGERQF in the last k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGERQF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cspcon"=>
  {"summary"=>
    ["CSPCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex symmetric packed matrix A using the",
     "factorization A = U*D*U**T or A = L*D*L**T computed by CSPTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CSPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSPTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ssytrf_rook"=>
  {"summary"=>
    ["SSYTRF_ROOK computes the factorization of a real symmetric matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method.",
     "The form of the factorization is",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k-1 and -IPIV(k-1) were inerchaged,",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k+1 and -IPIV(k+1) were inerchaged,",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "clahef_aa"=>
  {"summary"=>
    ["CLAHEF_AA factorizes a panel of a complex hermitian matrix A using",
     "the Aasen's algorithm. The panel consists of a set of NB rows of A",
     "when UPLO is U, or a set of NB columns when UPLO is L.",
     "In order to factorize the panel, the Aasen's algorithm requires the",
     "last row, or column, of the previous panel. The first row, or column,",
     "of A is set to be the first row, or column, of an identity matrix,",
     "which is used to factorize the first panel.",
     "The resulting J-th row of U, or J-th column of L, is stored in the",
     "(J-1)-th row, or column, of A (without the unit diagonals), while",
     "the diagonal and subdiagonal of A are overwritten by those of T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The location of the first row, or column, of the panel",
       "         within the submatrix of A, passed to this routine, e.g.,",
       "         when called by CHETRF_AA, for the first panel, J1 is 1,",
       "         while for the remaining panels, J1 is 2."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The dimension of the submatrix. M >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The dimension of the panel to be facotorized."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,M) for",
       "         the first panel, while dimension (LDA,M+1) for the",
       "         remaining panels.",
       "         On entry, A contains the last row, or column, of",
       "         the previous panel, and the trailing submatrix of A",
       "         to be factorized, except for the first panel, only",
       "         the panel is passed.",
       "         On exit, the leading panel is factorized."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the row and column interchanges,",
       "         the row and column k were interchanged with the row and",
       "         column IPIV(k)."],
     "H"=>["[in,out]", "         H is COMPLEX workspace, dimension (LDH,NB)."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the workspace H. LDH >= max(1,M)."],
     "WORK"=>["[out]", "         WORK is COMPLEX workspace, dimension (M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "strexc"=>
  {"summary"=>
    ["STREXC reorders the real Schur factorization of a real matrix",
     "A = Q*T*Q**T, so that the diagonal block of T with row index IFST is",
     "moved to row ILST.",
     "The real Schur form T is reordered by an orthogonal similarity",
     "transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors",
     "is updated by postmultiplying it with Z.",
     "T must be in Schur canonical form (as returned by SHSEQR), that is,",
     "block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each",
     "2-by-2 diagonal block has its diagonal elements equal and its",
     "off-diagonal elements of opposite sign."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'V':  update the matrix Q of Schur vectors;",
       "         = 'N':  do not update Q."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0.",
       "         If N == 0 arguments ILST and IFST may be any value."],
     "T"=>
      ["[in,out]",
       "         T is REAL array, dimension (LDT,N)",
       "         On entry, the upper quasi-triangular matrix T, in Schur",
       "         Schur canonical form.",
       "         On exit, the reordered upper quasi-triangular matrix, again",
       "         in Schur canonical form."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "         On entry, if COMPQ = 'V', the matrix Q of Schur vectors.",
       "         On exit, if COMPQ = 'V', Q has been postmultiplied by the",
       "         orthogonal transformation matrix Z which reorders T.",
       "         If COMPQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= 1, and if",
       "         COMPQ = 'V', LDQ >= max(1,N)."],
     "IFST"=>["[in,out]", "         IFST is INTEGER"],
     "ILST"=>
      ["[in,out]",
       "         ILST is INTEGER",
       "         Specify the reordering of the diagonal blocks of T.",
       "         The block with row index IFST is moved to row ILST, by a",
       "         sequence of transpositions between adjacent blocks.",
       "         On exit, if IFST pointed on entry to the second row of a",
       "         2-by-2 block, it is changed to point to the first row; ILST",
       "         always points to the first row of the block in its final",
       "         position (which may differ from its input value by +1 or -1).",
       "         1 <= IFST <= N; 1 <= ILST <= N."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         = 1:  two adjacent blocks were too close to swap (the problem",
       "               is very ill-conditioned); T may have been partially",
       "               reordered, and ILST points to the first row of the",
       "               current position of the block being moved."]}},
 "zgetri"=>
  {"summary"=>
    ["ZGETRI computes the inverse of a matrix using the LU factorization",
     "computed by ZGETRF.",
     "This method inverts U and then computes inv(A) by solving the system",
     "inv(A)*L = inv(U) for inv(A)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the factors L and U from the factorization",
       "         A = P*L*U as computed by ZGETRF.",
       "         On exit, if INFO = 0, the inverse of the original matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from ZGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO=0, then WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimal performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero; the matrix is",
       "               singular and its inverse could not be computed."]}},
 "dsysv_rook"=>
  {"summary"=>
    ["DSYSV_ROOK computes the solution to a real system of linear",
     "equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "DSYTRF_ROOK is called to compute the factorization of a real",
     "symmetric matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal",
     "pivoting method.",
     "The factored form of A is then used to solve the system",
     "of equations A * X = B by calling DSYTRS_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**T or A = L*D*L**T as computed by",
       "         DSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D,",
       "         as determined by DSYTRF_ROOK.",
       "         If UPLO = 'U':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k-1 and -IPIV(k-1) were inerchaged,",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k+1 and -IPIV(k+1) were inerchaged,",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         DSYTRF_ROOK.",
       "         TRS will be done with Level 2 BLAS",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "claset"=>
  {"summary"=>
    ["CLASET initializes a 2-D array A to BETA on the diagonal and",
     "ALPHA on the offdiagonals."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the part of the matrix A to be set.",
       "         = 'U':      Upper triangular part is set. The lower triangle",
       "                     is unchanged.",
       "         = 'L':      Lower triangular part is set. The upper triangle",
       "                     is unchanged.",
       "         Otherwise:  All of the matrix A is set."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         On entry, M specifies the number of rows of A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         On entry, N specifies the number of columns of A."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX",
       "         All the offdiagonal array elements are set to ALPHA."],
     "BETA"=>
      ["[in]",
       "         BETA is COMPLEX",
       "         All the diagonal array elements are set to BETA."],
     "A"=>
      ["[out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, A(i,j) = ALPHA, 1 <= i <= m, 1 <= j <= n, i.ne.j;",
       "                  A(i,i) = BETA , 1 <= i <= min(m,n)"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."]}},
 "ieeeck"=>
  {"summary"=>
    ["IEEECK is called from the ILAENV to verify that Infinity and",
     "possibly NaN arithmetic is safe (i.e. will not trap)."],
   "param"=>
    {"ISPEC"=>
      ["[in]",
       "         ISPEC is INTEGER",
       "         Specifies whether to test just for inifinity arithmetic",
       "         or whether to test for infinity and NaN arithmetic.",
       "         = 0: Verify infinity arithmetic only.",
       "         = 1: Verify infinity and NaN arithmetic."],
     "ZERO"=>
      ["[in]",
       "         ZERO is REAL",
       "         Must contain the value 0.0",
       "         This is passed to prevent the compiler from optimizing",
       "         away this code."],
     "ONE"=>
      ["[in]",
       "         ONE is REAL",
       "         Must contain the value 1.0",
       "         This is passed to prevent the compiler from optimizing",
       "         away this code.",
       " RETURN VALUE:  INTEGER",
       "         = 0:  Arithmetic failed to produce the correct answers",
       "         = 1:  Arithmetic produced the correct answers"]}},
 "sgerfsx"=>
  {"summary"=>
    ["   SGERFSX improves the computed solution to a system of linear",
     "   equations and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED, R",
     "   and C below. In this case, the solution and error bounds returned",
     "   are for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "              diag(R).",
       "      = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "              by diag(C).",
       "      = 'B':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(R) * A * diag(C).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    The original N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The factors L and U from the factorization A = P*L*U",
       "    as computed by SGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from SGETRF; for 1<=i<=N, row i of the",
       "    matrix was interchanged with row IPIV(i)."],
     "R"=>
      ["[in]",
       "         R is REAL array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'R' or 'B', A is",
       "    multiplied on the left by diag(R); if EQUED = 'N' or 'C', R",
       "    is not accessed.",
       "    If R is accessed, each element of R should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A.  If EQUED = 'C' or 'B', A is",
       "    multiplied on the right by diag(C); if EQUED = 'N' or 'R', C",
       "    is not accessed.",
       "    If C is accessed, each element of C should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by SGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is REAL array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "sgesdd"=>
  {"summary"=>
    ["SGESDD computes the singular value decomposition (SVD) of a real",
     "M-by-N matrix A, optionally computing the left and right singular",
     "vectors.  If singular vectors are desired, it uses a",
     "divide-and-conquer algorithm.",
     "The SVD is written",
     "     A = U * SIGMA * transpose(V)",
     "where SIGMA is an M-by-N matrix which is zero except for its",
     "min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and",
     "V is an N-by-N orthogonal matrix.  The diagonal elements of SIGMA",
     "are the singular values of A; they are real and non-negative, and",
     "are returned in descending order.  The first min(m,n) columns of",
     "U and V are the left and right singular vectors of A.",
     "Note that the routine returns VT = V**T, not V.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'A':  all M columns of U and all N rows of V**T are",
       "                 returned in the arrays U and VT;",
       "         = 'S':  the first min(M,N) columns of U and the first",
       "                 min(M,N) rows of V**T are returned in the arrays U",
       "                 and VT;",
       "         = 'O':  If M >= N, the first N columns of U are overwritten",
       "                 on the array A and all rows of V**T are returned in",
       "                 the array VT;",
       "                 otherwise, all columns of U are returned in the",
       "                 array U and the first M rows of V**T are overwritten",
       "                 in the array A;",
       "         = 'N':  no columns of U or rows of V**T are computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if JOBZ = 'O',  A is overwritten with the first N columns",
       "                         of U (the left singular vectors, stored",
       "                         columnwise) if M >= N;",
       "                         A is overwritten with the first M rows",
       "                         of V**T (the right singular vectors, stored",
       "                         rowwise) otherwise.",
       "         if JOBZ .ne. 'O', the contents of A are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is REAL array, dimension (LDU,UCOL)",
       "         UCOL = M if JOBZ = 'A' or JOBZ = 'O' and M < N;",
       "         UCOL = min(M,N) if JOBZ = 'S'.",
       "         If JOBZ = 'A' or JOBZ = 'O' and M < N, U contains the M-by-M",
       "         orthogonal matrix U;",
       "         if JOBZ = 'S', U contains the first min(M,N) columns of U",
       "         (the left singular vectors, stored columnwise);",
       "         if JOBZ = 'O' and M >= N, or JOBZ = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1; if",
       "         JOBZ = 'S' or 'A' or JOBZ = 'O' and M < N, LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is REAL array, dimension (LDVT,N)",
       "         If JOBZ = 'A' or JOBZ = 'O' and M >= N, VT contains the",
       "         N-by-N orthogonal matrix V**T;",
       "         if JOBZ = 'S', VT contains the first min(M,N) rows of",
       "         V**T (the right singular vectors, stored rowwise);",
       "         if JOBZ = 'O' and M < N, or JOBZ = 'N', VT is not referenced."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1;",
       "         if JOBZ = 'A' or JOBZ = 'O' and M >= N, LDVT >= N;",
       "         if JOBZ = 'S', LDVT >= min(M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK;"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= 1.",
       "         If LWORK = -1, a workspace query is assumed.  The optimal",
       "         size for the WORK array is calculated and stored in WORK(1),",
       "         and no other work except argument checking is performed.",
       "         Let mx = max(M,N) and mn = min(M,N).",
       "         If JOBZ = 'N', LWORK >= 3*mn + max( mx, 7*mn ).",
       "         If JOBZ = 'O', LWORK >= 3*mn + max( mx, 5*mn*mn + 4*mn ).",
       "         If JOBZ = 'S', LWORK >= 4*mn*mn + 7*mn.",
       "         If JOBZ = 'A', LWORK >= 4*mn*mn + 6*mn + mx.",
       "         These are not tight minimums in all cases; see comments inside code.",
       "         For good performance, LWORK should generally be larger;",
       "         a query is recommended."],
     "IWORK"=>
      ["[out]", "         IWORK is INTEGER array, dimension (8*min(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  SBDSDC did not converge, updating process failed."]}},
 "zlaqr0"=>
  {"summary"=>
    ["   ZLAQR0 computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**H, where T is an upper triangular matrix (the",
     "   Schur form), and Z is the unitary matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input unitary",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the unitary matrix Q:  A = Q*H*Q**H = (QZ)*H*(QZ)**H."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N and, if ILO.GT.1,",
       "          H(ILO,ILO-1) is zero. ILO and IHI are normally set by a",
       "          previous call to ZGEBAL, and then passed to ZGEHRD when the",
       "          matrix output by ZGEBAL is reduced to Hessenberg form.",
       "          Otherwise, ILO and IHI should be set to 1 and N,",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX*16 array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and WANTT is .TRUE., then H",
       "          contains the upper triangular matrix T from the Schur",
       "          decomposition (the Schur form). If INFO = 0 and WANT is",
       "          .FALSE., then the contents of H are unspecified on exit.",
       "          (The output value of H when INFO.GT.0 is given under the",
       "          description of INFO below.)",
       "          This subroutine may explicitly set H(i,j) = 0 for i.GT.j and",
       "          j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX*16 array, dimension (N)",
       "          The computed eigenvalues of H(ILO:IHI,ILO:IHI) are stored",
       "          in W(ILO:IHI). If WANTT is .TRUE., then the eigenvalues are",
       "          stored in the same order as on the diagonal of the Schur",
       "          form returned in H, with W(i) = H(i,i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "          Specify the rows of Z to which transformations must be",
       "          applied if WANTZ is .TRUE..",
       "          1 .LE. ILOZ .LE. ILO; IHI .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ,IHI)",
       "          If WANTZ is .FALSE., then Z is not referenced.",
       "          If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is",
       "          replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the",
       "          orthogonal Schur factor of H(ILO:IHI,ILO:IHI).",
       "          (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if WANTZ is .TRUE.",
       "          then LDZ.GE.MAX(1,IHIZ).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension LWORK",
       "          On exit, if LWORK = -1, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient, but LWORK typically as large as 6*N may",
       "          be required for optimal performance.  A workspace query",
       "          to determine the optimal workspace size is recommended.",
       "          If LWORK = -1, then ZLAQR0 does a workspace query.",
       "          In this case, ZLAQR0 checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .GT. 0:  if INFO = i, ZLAQR0 failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and WANT is .FALSE., then on exit,",
       "               the remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is a unitary matrix.  The final",
       "               value of  H is upper Hessenberg and triangular in",
       "               rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                 (final value of Z(ILO:IHI,ILOZ:IHIZ)",
       "                  =  (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U",
       "               where U is the unitary matrix in (*) (regard-",
       "               less of the value of WANTT.)",
       "               If INFO .GT. 0 and WANTZ is .FALSE., then Z is not",
       "               accessed."]}},
 "ssyev"=>
  {"summary"=>
    ["SSYEV computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric matrix A."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,3*N-1).",
       "         For optimal efficiency, LWORK >= (NB+2)*N,",
       "         where NB is the blocksize for SSYTRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "cla_gerpvgrw"=>
  {"summary"=>
    ["CLA_GERPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A. NCOLS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by CGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."]}},
 "dspevx"=>
  {"summary"=>
    ["DSPEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A in packed storage.  Eigenvalues/vectors",
     "can be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AP to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the selected eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (8*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "zla_porcond_c"=>
  {"summary"=>
    ["   ZLA_PORCOND_C Computes the infinity norm condition number of",
     "   op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector"],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**H*U or A = L*L**H, as computed by ZPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The vector C in the formula op(A) * inv(diag(C))."],
     "CAPPLY"=>
      ["[in]",
       "         CAPPLY is LOGICAL",
       "    If .TRUE. then access the vector C in the formula above."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX*16 array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is DOUBLE PRECISION array, dimension (N).",
       "    Workspace."]}},
 "dsytri2x"=>
  {"summary"=>
    ["DSYTRI2X computes the inverse of a real symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "DSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the NNB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by DSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NNB structure of D",
       "         as determined by DSYTRF."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (N+NNB+1,NNB+3)"],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "csptri"=>
  {"summary"=>
    ["CSPTRI computes the inverse of a complex symmetric indefinite matrix",
     "A in packed storage using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by CSPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CSPTRF,",
       "         stored as a packed triangular matrix.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix, stored as a packed triangular matrix. The j-th column",
       "         of inv(A) is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;",
       "         if UPLO = 'L',",
       "            AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSPTRF."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "slarrc"=>
  {"summary"=>
    ["Find the number of eigenvalues of the symmetric tridiagonal matrix T",
     "that are in the interval (VL,VU] if JOBT = 'T', and of L D L^T",
     "if JOBT = 'L'."],
   "param"=>
    {"JOBT"=>
      ["[in]",
       "         JOBT is CHARACTER*1",
       "         = 'T':  Compute Sturm count for matrix T.",
       "         = 'L':  Compute Sturm count for matrix L D L^T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix. N > 0."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         The lower bound for the eigenvalues."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         The upper bound for the eigenvalues."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         JOBT = 'T': The N diagonal elements of the tridiagonal matrix T.",
       "         JOBT = 'L': The N diagonal elements of the diagonal matrix D."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N)",
       "         JOBT = 'T': The N-1 offdiagonal elements of the matrix T.",
       "         JOBT = 'L': The N-1 offdiagonal elements of the matrix L."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "         The minimum pivot in the Sturm sequence for T."],
     "EIGCNT"=>
      ["[out]",
       "         EIGCNT is INTEGER",
       "         The number of eigenvalues of the symmetric tridiagonal matrix T",
       "         that are in the interval (VL,VU]"],
     "LCNT"=>["[out]", "         LCNT is INTEGER"],
     "RCNT"=>
      ["[out]",
       "         RCNT is INTEGER",
       "         The left and right negcounts of the interval."],
     "INFO"=>["[out]", "         INFO is INTEGER"]}},
 "dlarrc"=>
  {"summary"=>
    ["Find the number of eigenvalues of the symmetric tridiagonal matrix T",
     "that are in the interval (VL,VU] if JOBT = 'T', and of L D L^T",
     "if JOBT = 'L'."],
   "param"=>
    {"JOBT"=>
      ["[in]",
       "         JOBT is CHARACTER*1",
       "         = 'T':  Compute Sturm count for matrix T.",
       "         = 'L':  Compute Sturm count for matrix L D L^T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix. N > 0."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         The lower bound for the eigenvalues."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         The upper bound for the eigenvalues."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         JOBT = 'T': The N diagonal elements of the tridiagonal matrix T.",
       "         JOBT = 'L': The N diagonal elements of the diagonal matrix D."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         JOBT = 'T': The N-1 offdiagonal elements of the matrix T.",
       "         JOBT = 'L': The N-1 offdiagonal elements of the matrix L."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "         The minimum pivot in the Sturm sequence for T."],
     "EIGCNT"=>
      ["[out]",
       "         EIGCNT is INTEGER",
       "         The number of eigenvalues of the symmetric tridiagonal matrix T",
       "         that are in the interval (VL,VU]"],
     "LCNT"=>["[out]", "         LCNT is INTEGER"],
     "RCNT"=>
      ["[out]",
       "         RCNT is INTEGER",
       "         The left and right negcounts of the interval."],
     "INFO"=>["[out]", "         INFO is INTEGER"]}},
 "dggev3"=>
  {"summary"=>
    ["DGGEV3 computes for a pair of N-by-N real nonsymmetric matrices (A,B)",
     "the generalized eigenvalues, and optionally, the left and/or right",
     "generalized eigenvectors.",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right eigenvector v(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 A * v(j) = lambda(j) * B * v(j).",
     "The left eigenvector u(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 u(j)**H * A  = lambda(j) * u(j)**H * B .",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHAR"=>
      ["[out]", "         ALPHAR is DOUBLE PRECISION array, dimension (N)"],
     "ALPHAI"=>
      ["[out]", "         ALPHAI is DOUBLE PRECISION array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  If ALPHAI(j) is zero, then",
       "         the j-th eigenvalue is real; if positive, then the j-th and",
       "         (j+1)-st eigenvalues are a complex conjugate pair, with",
       "         ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio",
       "         alpha/beta.  However, ALPHAR and ALPHAI will be always less",
       "         than and usually comparable with norm(A) in magnitude, and",
       "         BETA always less than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is DOUBLE PRECISION array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         u(j) = VL(:,j), the j-th column of VL. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         u(j) = VL(:,j)+i*VL(:,j+1) and u(j+1) = VL(:,j)-i*VL(:,j+1).",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part)+abs(imag. part)=1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is DOUBLE PRECISION array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         v(j) = VR(:,j), the j-th column of VR. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1).",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part)+abs(imag. part)=1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHAR(j), ALPHAI(j), and BETA(j)",
       "               should be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in DHGEQZ.",
       "               =N+2: error return from DTGEVC."]}},
 "zpptrf"=>
  {"summary"=>
    ["ZPPTRF computes the Cholesky factorization of a complex Hermitian",
     "positive definite matrix A stored in packed format.",
     "The factorization has the form",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H*U or A = L*L**H, in the same",
       "         storage format as A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "dla_syamv"=>
  {"summary"=>
    ["DLA_SYAMV  performs the matrix-vector operation",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "n by n symmetric matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is INTEGER",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array A is to be referenced as",
       "          follows:",
       "             UPLO = BLAS_UPPER   Only the upper triangular part of A",
       "                                 is to be referenced.",
       "             UPLO = BLAS_LOWER   Only the lower triangular part of A",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION .",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array of DIMENSION ( LDA, n ).",
       "          Before entry, the leading m by n part of the array A must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, n ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is DOUBLE PRECISION array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCX ) )",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION .",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCY ) )",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit."]}},
 "clacpy"=>
  {"summary"=>
    ["CLACPY copies all or part of a two-dimensional matrix A to another",
     "matrix B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the part of the matrix A to be copied to B.",
       "         = 'U':      Upper triangular part",
       "         = 'L':      Lower triangular part",
       "         Otherwise:  All of the matrix A"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The m by n matrix A.  If UPLO = 'U', only the upper trapezium",
       "         is accessed; if UPLO = 'L', only the lower trapezium is",
       "         accessed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On exit, B = A in the locations specified by UPLO."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."]}},
 "chegv_2stage"=>
  {"summary"=>
    ["CHEGV_2STAGE computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be Hermitian and B is also",
     "positive definite.",
     "This routine use the 2stage technique for the reduction to tridiagonal",
     "which showed higher performance on recent architecture and for large"],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the Hermitian positive definite matrix B.",
       "         If UPLO = 'U', the leading N-by-N upper triangular part of B",
       "         contains the upper triangular part of the matrix B.",
       "         If UPLO = 'L', the leading N-by-N lower triangular part of B",
       "         contains the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is REAL array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  CPOTRF or CHEEV returned an error code:",
       "            <= N:  if INFO = i, CHEEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "dlaed8"=>
  {"summary"=>
    ["DLAED8 merges the two sets of eigenvalues together into a single",
     "sorted set.  Then it tries to deflate the size of the problem.",
     "There are two ways in which deflation can occur:  when two or more",
     "eigenvalues are close together or if there is a tiny element in the",
     "Z vector.  For each such occurrence the order of the related secular",
     "equation problem is reduced by one."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "         = 0:  Compute eigenvalues only.",
       "         = 1:  Compute eigenvectors of original dense symmetric matrix",
       "               also.  On entry, Q contains the orthogonal matrix used",
       "               to reduce the original matrix to tridiagonal form."],
     "K"=>
      ["[out]",
       "         K is INTEGER",
       "        The number of non-deflated eigenvalues, and the order of the",
       "        related secular equation."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the orthogonal matrix used to reduce",
       "        the full matrix to tridiagonal form.  QSIZ >= N if ICOMPQ = 1."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        On entry, the eigenvalues of the two submatrices to be",
       "        combined.  On exit, the trailing (N-K) updated eigenvalues",
       "        (those which were deflated) sorted into increasing order."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "        If ICOMPQ = 0, Q is not referenced.  Otherwise,",
       "        on entry, Q contains the eigenvectors of the partially solved",
       "        system which has been previously updated in matrix",
       "        multiplies with other partially solved eigensystems.",
       "        On exit, Q contains the trailing (N-K) updated eigenvectors",
       "        (those which were deflated) in its last N-K columns."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "INDXQ"=>
      ["[in]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        The permutation which separately sorts the two sub-problems",
       "        in D into ascending order.  Note that elements in the second",
       "        half of this permutation must first have CUTPNT added to",
       "        their values in order to be accurate."],
     "RHO"=>
      ["[in,out]",
       "         RHO is DOUBLE PRECISION",
       "        On entry, the off-diagonal element associated with the rank-1",
       "        cut which originally split the two submatrices which are now",
       "        being recombined.",
       "        On exit, RHO has been modified to the value required by",
       "        DLAED3."],
     "CUTPNT"=>
      ["[in]",
       "         CUTPNT is INTEGER",
       "        The location of the last eigenvalue in the leading",
       "        sub-matrix.  min(1,N) <= CUTPNT <= N."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension (N)",
       "        On entry, Z contains the updating vector (the last row of",
       "        the first sub-eigenvector matrix and the first row of the",
       "        second sub-eigenvector matrix).",
       "        On exit, the contents of Z are destroyed by the updating",
       "        process."],
     "DLAMDA"=>
      ["[out]",
       "         DLAMDA is DOUBLE PRECISION array, dimension (N)",
       "        A copy of the first K eigenvalues which will be used by",
       "        DLAED3 to form the secular equation."],
     "Q2"=>
      ["[out]",
       "         Q2 is DOUBLE PRECISION array, dimension (LDQ2,N)",
       "        If ICOMPQ = 0, Q2 is not referenced.  Otherwise,",
       "        a copy of the first K eigenvectors which will be used by",
       "        DLAED7 in a matrix multiply (DGEMM) to update the new",
       "        eigenvectors."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "        The leading dimension of the array Q2.  LDQ2 >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "        The first k values of the final deflation-altered z-vector and",
       "        will be passed to DLAED3."],
     "PERM"=>
      ["[out]",
       "         PERM is INTEGER array, dimension (N)",
       "        The permutations (from deflation and sorting) to be applied",
       "        to each eigenblock."],
     "GIVPTR"=>
      ["[out]",
       "         GIVPTR is INTEGER",
       "        The number of Givens rotations which took place in this",
       "        subproblem."],
     "GIVCOL"=>
      ["[out]",
       "         GIVCOL is INTEGER array, dimension (2, N)",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation."],
     "GIVNUM"=>
      ["[out]",
       "         GIVNUM is DOUBLE PRECISION array, dimension (2, N)",
       "        Each number indicates the S value to be used in the",
       "        corresponding Givens rotation."],
     "INDXP"=>
      ["[out]",
       "         INDXP is INTEGER array, dimension (N)",
       "        The permutation used to place deflated values of D at the end",
       "        of the array.  INDXP(1:K) points to the nondeflated D-values",
       "        and INDXP(K+1:N) points to the deflated eigenvalues."],
     "INDX"=>
      ["[out]",
       "         INDX is INTEGER array, dimension (N)",
       "        The permutation used to sort the contents of D into ascending",
       "        order."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slarra"=>
  {"summary"=>
    ["Compute the splitting points with threshold SPLTOL.",
     "SLARRA sets any \"small\" off-diagonal elements to zero."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix. N > 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal",
       "         matrix T."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N)",
       "         On entry, the first (N-1) entries contain the subdiagonal",
       "         elements of the tridiagonal matrix T; E(N) need not be set.",
       "         On exit, the entries E( ISPLIT( I ) ), 1 <= I <= NSPLIT,",
       "         are set to zero, the other entries of E are untouched."],
     "E2"=>
      ["[in,out]",
       "         E2 is REAL array, dimension (N)",
       "         On entry, the first (N-1) entries contain the SQUARES of the",
       "         subdiagonal elements of the tridiagonal matrix T;",
       "         E2(N) need not be set.",
       "         On exit, the entries E2( ISPLIT( I ) ),",
       "         1 <= I <= NSPLIT, have been set to zero"],
     "SPLTOL"=>
      ["[in]",
       "         SPLTOL is REAL",
       "         The threshold for splitting. Two criteria can be used:",
       "         SPLTOL<0 : criterion based on absolute off-diagonal value",
       "         SPLTOL>0 : criterion that preserves relative accuracy"],
     "TNRM"=>
      ["[in]", "         TNRM is REAL", "         The norm of the matrix."],
     "NSPLIT"=>
      ["[out]",
       "         NSPLIT is INTEGER",
       "         The number of blocks T splits into. 1 <= NSPLIT <= N."],
     "ISPLIT"=>
      ["[out]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into blocks.",
       "         The first block consists of rows/columns 1 to ISPLIT(1),",
       "         the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),",
       "         etc., and the NSPLIT-th consists of rows/columns",
       "         ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit"]}},
 "dtprfb"=>
  {"summary"=>
    ["DTPRFB applies a real \"triangular-pentagonal\" block reflector H or its",
     "transpose H**T to a real matrix C, which is composed of two",
     "blocks A and B, either from the left or right."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H**T from the Left",
       "         = 'R': apply H or H**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'T': apply H**T (Transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columns",
       "         = 'R': Rows"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B.",
       "         N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T, i.e. the number of elementary",
       "         reflectors whose product defines the block reflector.",
       "         K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension",
       "                               (LDV,K) if STOREV = 'C'",
       "                               (LDV,M) if STOREV = 'R' and SIDE = 'L'",
       "                               (LDV,N) if STOREV = 'R' and SIDE = 'R'",
       "         The pentagonal matrix V, which contains the elementary reflectors",
       "         H(1), H(2), ..., H(K).  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);",
       "         if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);",
       "         if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (LDT,K)",
       "         The triangular K-by-K matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.",
       "         LDT >= K."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension",
       "         (LDA,N) if SIDE = 'L' or (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         H*C or H**T*C or C*H or C*H**T.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         H*C or H**T*C or C*H or C*H**T.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension",
       "         (LDWORK,N) if SIDE = 'L',",
       "         (LDWORK,K) if SIDE = 'R'."],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= K;",
       "         if SIDE = 'R', LDWORK >= M."]}},
 "zgbcon"=>
  {"summary"=>
    ["ZGBCON estimates the reciprocal of the condition number of a complex",
     "general band matrix A, in either the 1-norm or the infinity-norm,",
     "using the LU factorization computed by ZGBTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by ZGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= N, row i of the matrix was",
       "         interchanged with row IPIV(i)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaed2"=>
  {"summary"=>
    ["DLAED2 merges the two sets of eigenvalues together into a single",
     "sorted set.  Then it tries to deflate the size of the problem.",
     "There are two ways in which deflation can occur:  when two or more",
     "eigenvalues are close together or if there is a tiny entry in the",
     "Z vector.  For each such occurrence the order of the related secular",
     "equation problem is reduced by one."],
   "param"=>
    {"K"=>
      ["[out]",
       "         K is INTEGER",
       "        The number of non-deflated eigenvalues, and the order of the",
       "        related secular equation. 0 <= K <=N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "        The location of the last eigenvalue in the leading sub-matrix.",
       "        min(1,N) <= N1 <= N/2."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        On entry, D contains the eigenvalues of the two submatrices to",
       "        be combined.",
       "        On exit, D contains the trailing (N-K) updated eigenvalues",
       "        (those which were deflated) sorted into increasing order."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ, N)",
       "        On entry, Q contains the eigenvectors of two submatrices in",
       "        the two square blocks with corners at (1,1), (N1,N1)",
       "        and (N1+1, N1+1), (N,N).",
       "        On exit, Q contains the trailing (N-K) updated eigenvectors",
       "        (those which were deflated) in its last N-K columns."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "INDXQ"=>
      ["[in,out]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        The permutation which separately sorts the two sub-problems",
       "        in D into ascending order.  Note that elements in the second",
       "        half of this permutation must first have N1 added to their",
       "        values. Destroyed on exit."],
     "RHO"=>
      ["[in,out]",
       "         RHO is DOUBLE PRECISION",
       "        On entry, the off-diagonal element associated with the rank-1",
       "        cut which originally split the two submatrices which are now",
       "        being recombined.",
       "        On exit, RHO has been modified to the value required by",
       "        DLAED3."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension (N)",
       "        On entry, Z contains the updating vector (the last",
       "        row of the first sub-eigenvector matrix and the first row of",
       "        the second sub-eigenvector matrix).",
       "        On exit, the contents of Z have been destroyed by the updating",
       "        process."],
     "DLAMDA"=>
      ["[out]",
       "         DLAMDA is DOUBLE PRECISION array, dimension (N)",
       "        A copy of the first K eigenvalues which will be used by",
       "        DLAED3 to form the secular equation."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "        The first k values of the final deflation-altered z-vector",
       "        which will be passed to DLAED3."],
     "Q2"=>
      ["[out]",
       "         Q2 is DOUBLE PRECISION array, dimension (N1**2+(N-N1)**2)",
       "        A copy of the first K eigenvectors which will be used by",
       "        DLAED3 in a matrix multiply (DGEMM) to solve for the new",
       "        eigenvectors."],
     "INDX"=>
      ["[out]",
       "         INDX is INTEGER array, dimension (N)",
       "        The permutation used to sort the contents of DLAMDA into",
       "        ascending order."],
     "INDXC"=>
      ["[out]",
       "         INDXC is INTEGER array, dimension (N)",
       "        The permutation used to arrange the columns of the deflated",
       "        Q matrix into three groups:  the first group contains non-zero",
       "        elements only at and above N1, the second contains",
       "        non-zero elements only below N1, and the third is dense."],
     "INDXP"=>
      ["[out]",
       "         INDXP is INTEGER array, dimension (N)",
       "        The permutation used to place deflated values of D at the end",
       "        of the array.  INDXP(1:K) points to the nondeflated D-values",
       "        and INDXP(K+1:N) points to the deflated eigenvalues."],
     "COLTYP"=>
      ["[out]",
       "         COLTYP is INTEGER array, dimension (N)",
       "        During execution, a label which will indicate which of the",
       "        following types a column in the Q2 matrix is:",
       "        1 : non-zero in the upper half only;",
       "        2 : dense;",
       "        3 : non-zero in the lower half only;",
       "        4 : deflated.",
       "        On exit, COLTYP(i) is the number of columns of type i,",
       "        for i=1 to 4 only."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ssbevx"=>
  {"summary"=>
    ["SSBEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric band matrix A.  Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "Q"=>
      ["[out]",
       "         Q is REAL array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the N-by-N orthogonal matrix used in the",
       "                        reduction to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'V', then",
       "         LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AB to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "dla_syrfsx_extended"=>
  {"summary"=>
    ["DLA_SYRFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by DSYRFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by DSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by DSYTRF."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension",
       "                   (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by DSYTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by DLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is DOUBLE PRECISION array, dimension (N)",
       "    Workspace. This can be the same workspace passed for Y_TAIL."],
     "DY"=>
      ["[in]",
       "         DY is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is DOUBLE PRECISION",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is DOUBLE PRECISION",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to DLA_SYRFSX_EXTENDED had an illegal",
       "            value"]}},
 "ztrtrs"=>
  {"summary"=>
    ["ZTRTRS solves a triangular system of the form",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B,",
     "where A is a triangular matrix of order N, and B is an N-by-NRHS",
     "matrix.  A check is made to verify that A is nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, the i-th diagonal element of A is zero,",
       "              indicating that the matrix is singular and the solutions",
       "              X have not been computed."]}},
 "dgerq2"=>
  {"summary"=>
    ["DGERQ2 computes an RQ factorization of a real m by n matrix A:",
     "A = R * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, if m <= n, the upper triangle of the subarray",
       "         A(1:m,n-m+1:n) contains the m by m upper triangular matrix R;",
       "         if m >= n, the elements on and above the (m-n)-th subdiagonal",
       "         contain the m by n upper trapezoidal matrix R; the remaining",
       "         elements, with the array TAU, represent the orthogonal matrix",
       "         Q as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dgges3"=>
  {"summary"=>
    ["DGGES3 computes for a pair of N-by-N real nonsymmetric matrices (A,B),",
     "the generalized eigenvalues, the generalized real Schur form (S,T),",
     "optionally, the left and/or right matrices of Schur vectors (VSL and",
     "VSR). This gives the generalized Schur factorization",
     "         (A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T )",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "quasi-triangular matrix S and the upper triangular matrix T.The",
     "leading columns of VSL and VSR then form an orthonormal basis for the",
     "corresponding left and right eigenspaces (deflating subspaces).",
     "(If only the generalized eigenvalues are needed, use the driver",
     "DGGEV instead, which is faster.)",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0 or both being zero.",
     "A pair of matrices (S,T) is in generalized real Schur form if T is",
     "upper triangular with non-negative diagonal and S is block upper",
     "triangular with 1-by-1 and 2-by-2 blocks.  1-by-1 blocks correspond",
     "to real generalized eigenvalues, while 2-by-2 blocks of S will be",
     "\"standardized\" by making the corresponding elements of T have the",
     "form:",
     "        [  a  0  ]",
     "        [  0  b  ]",
     "and the pair of corresponding 2-by-2 blocks in S and T will have a",
     "complex conjugate pair of generalized eigenvalues."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG);"],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is a LOGICAL FUNCTION of three DOUBLE PRECISION arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         An eigenvalue (ALPHAR(j)+ALPHAI(j))/BETA(j) is selected if",
       "         SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) is true; i.e. if either",
       "         one of a complex conjugate pair of eigenvalues is selected,",
       "         then both complex eigenvalues are selected.",
       "         Note that in the ill-conditioned case, a selected complex",
       "         eigenvalue may no longer satisfy SELCTG(ALPHAR(j),ALPHAI(j),",
       "         BETA(j)) = .TRUE. after ordering. INFO is to be set to N+2",
       "         in this case."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true.  (Complex conjugate pairs for which",
       "         SELCTG is true for either eigenvalue count as 2.)"],
     "ALPHAR"=>
      ["[out]", "         ALPHAR is DOUBLE PRECISION array, dimension (N)"],
     "ALPHAI"=>
      ["[out]", "         ALPHAI is DOUBLE PRECISION array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  ALPHAR(j) + ALPHAI(j)*i,",
       "         and  BETA(j),j=1,...,N are the diagonals of the complex Schur",
       "         form (S,T) that would result if the 2-by-2 diagonal blocks of",
       "         the real Schur form of (A,B) were further reduced to",
       "         triangular form using 2-by-2 complex unitary transformations.",
       "         If ALPHAI(j) is zero, then the j-th eigenvalue is real; if",
       "         positive, then the j-th and (j+1)-st eigenvalues are a",
       "         complex conjugate pair, with ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio.",
       "         However, ALPHAR and ALPHAI will be always less than and",
       "         usually comparable with norm(A) in magnitude, and BETA always",
       "         less than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is DOUBLE PRECISION array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >=1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is DOUBLE PRECISION array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHAR(j), ALPHAI(j), and BETA(j) should",
       "               be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in DHGEQZ.",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in DTGSEN."]}},
 "dpptri"=>
  {"summary"=>
    ["DPPTRI computes the inverse of a real symmetric positive definite",
     "matrix A using the Cholesky factorization A = U**T*U or A = L*L**T",
     "computed by DPPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor is stored in AP;",
       "         = 'L':  Lower triangular factor is stored in AP."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the triangular factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T, packed columnwise as",
       "         a linear array.  The j-th column of U or L is stored in the",
       "         array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n.",
       "         On exit, the upper or lower triangle of the (symmetric)",
       "         inverse of A, overwriting the input factor U or L."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "chesvxx"=>
  {"summary"=>
    ["   CHESVXX uses the diagonal pivoting factorization to compute the",
     "   solution to a complex system of linear equations A * X = B, where",
     "   A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "   matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. CHESVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   CHESVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   CHESVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what CHESVXX would itself produce."],
   "param"=>nil},
 "slasyf_rk"=>
  {"summary"=>
    ["SLASYF_RK computes a partial factorization of a real symmetric",
     "matrix A using the bounded Bunch-Kaufman (rook) diagonal",
     "pivoting method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**T L21**T )  if UPLO = 'L',",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "SLASYF_RK is an auxiliary routine called by SSYTRF_RK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,N-KB+1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,1:KB).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "W"=>["[out]", "         W is REAL array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "csytrs"=>
  {"summary"=>
    ["CSYTRS solves a system of linear equations A*X = B with a complex",
     "symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by CSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cunmrz"=>
  {"summary"=>
    ["CUNMRZ overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by CTZRZF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing",
       "         the meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CTZRZF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CTZRZF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zpbstf"=>
  {"summary"=>
    ["ZPBSTF computes a split Cholesky factorization of a complex",
     "Hermitian positive definite band matrix A.",
     "This routine is designed to be used in conjunction with ZHBGST.",
     "The factorization has the form  A = S**H*S  where S is a band matrix",
     "of the same bandwidth as A and the following structure:",
     "  S = ( U    )",
     "      ( M  L )",
     "where U is upper triangular of order m = (n+kd)/2, and L is lower",
     "triangular of order n-m."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first kd+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the factor S from the split Cholesky",
       "         factorization A = S**H*S. See Further Details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, the factorization could not be completed,",
       "              because the updated element a(i,i) was negative; the",
       "              matrix A is not positive definite."]}},
 "clansy"=>
  {"summary"=>
    ["CLANSY  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex symmetric matrix A.",
     "   CLANSY = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANSY as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is to be referenced.",
       "         = 'U':  Upper triangular part of A is referenced",
       "         = 'L':  Lower triangular part of A is referenced"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANSY is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The symmetric matrix A.  If UPLO = 'U', the leading n by n",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading n by n lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "zspsvx"=>
  {"summary"=>
    ["ZSPSVX uses the diagonal pivoting factorization A = U*D*U**T or",
     "A = L*D*L**T to compute the solution to a complex system of linear",
     "equations A * X = B, where A is an N-by-N symmetric matrix stored",
     "in packed format and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "ssyevx"=>
  {"summary"=>
    ["SSYEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A.  Eigenvalues and eigenvectors can be",
     "selected by specifying either a range of values or a range of indices",
     "for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= 1, when N <= 1;",
       "         otherwise 8*N.",
       "         For optimal efficiency, LWORK >= (NB+3)*N,",
       "         where NB is the max of the blocksize for SSYTRD and SORMTR",
       "         returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "claed8"=>
  {"summary"=>
    ["CLAED8 merges the two sets of eigenvalues together into a single",
     "sorted set.  Then it tries to deflate the size of the problem.",
     "There are two ways in which deflation can occur:  when two or more",
     "eigenvalues are close together or if there is a tiny element in the",
     "Z vector.  For each such occurrence the order of the related secular",
     "equation problem is reduced by one."],
   "param"=>
    {"K"=>
      ["[out]",
       "         K is INTEGER",
       "        Contains the number of non-deflated eigenvalues.",
       "        This is the order of the related secular equation."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the unitary matrix used to reduce",
       "        the dense or band matrix to tridiagonal form.",
       "        QSIZ >= N if ICOMPQ = 1."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDQ,N)",
       "        On entry, Q contains the eigenvectors of the partially solved",
       "        system which has been previously updated in matrix",
       "        multiplies with other partially solved eigensystems.",
       "        On exit, Q contains the trailing (N-K) updated eigenvectors",
       "        (those which were deflated) in its last N-K columns."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max( 1, N )."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry, D contains the eigenvalues of the two submatrices to",
       "        be combined.  On exit, D contains the trailing (N-K) updated",
       "        eigenvalues (those which were deflated) sorted into increasing",
       "        order."],
     "RHO"=>
      ["[in,out]",
       "         RHO is REAL",
       "        Contains the off diagonal element associated with the rank-1",
       "        cut which originally split the two submatrices which are now",
       "        being recombined. RHO is modified during the computation to",
       "        the value required by SLAED3."],
     "CUTPNT"=>
      ["[in]",
       "         CUTPNT is INTEGER",
       "        Contains the location of the last eigenvalue in the leading",
       "        sub-matrix.  MIN(1,N) <= CUTPNT <= N."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension (N)",
       "        On input this vector contains the updating vector (the last",
       "        row of the first sub-eigenvector matrix and the first row of",
       "        the second sub-eigenvector matrix).  The contents of Z are",
       "        destroyed during the updating process."],
     "DLAMDA"=>
      ["[out]",
       "         DLAMDA is REAL array, dimension (N)",
       "        Contains a copy of the first K eigenvalues which will be used",
       "        by SLAED3 to form the secular equation."],
     "Q2"=>
      ["[out]",
       "         Q2 is COMPLEX array, dimension (LDQ2,N)",
       "        If ICOMPQ = 0, Q2 is not referenced.  Otherwise,",
       "        Contains a copy of the first K eigenvectors which will be used",
       "        by SLAED7 in a matrix multiply (SGEMM) to update the new",
       "        eigenvectors."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "        The leading dimension of the array Q2.  LDQ2 >= max( 1, N )."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "        This will hold the first k values of the final",
       "        deflation-altered z-vector and will be passed to SLAED3."],
     "INDXP"=>
      ["[out]",
       "         INDXP is INTEGER array, dimension (N)",
       "        This will contain the permutation used to place deflated",
       "        values of D at the end of the array. On output INDXP(1:K)",
       "        points to the nondeflated D-values and INDXP(K+1:N)",
       "        points to the deflated eigenvalues."],
     "INDX"=>
      ["[out]",
       "         INDX is INTEGER array, dimension (N)",
       "        This will contain the permutation used to sort the contents of",
       "        D into ascending order."],
     "INDXQ"=>
      ["[in]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        This contains the permutation which separately sorts the two",
       "        sub-problems in D into ascending order.  Note that elements in",
       "        the second half of this permutation must first have CUTPNT",
       "        added to their values in order to be accurate."],
     "PERM"=>
      ["[out]",
       "         PERM is INTEGER array, dimension (N)",
       "        Contains the permutations (from deflation and sorting) to be",
       "        applied to each eigenblock."],
     "GIVPTR"=>
      ["[out]",
       "         GIVPTR is INTEGER",
       "        Contains the number of Givens rotations which took place in",
       "        this subproblem."],
     "GIVCOL"=>
      ["[out]",
       "         GIVCOL is INTEGER array, dimension (2, N)",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation."],
     "GIVNUM"=>
      ["[out]",
       "         GIVNUM is REAL array, dimension (2, N)",
       "        Each number indicates the S value to be used in the",
       "        corresponding Givens rotation."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "cggqrf"=>
  {"summary"=>
    ["CGGQRF computes a generalized QR factorization of an N-by-M matrix A",
     "and an N-by-P matrix B:",
     "            A = Q*R,        B = Q*T*Z,",
     "where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix,",
     "and R and T assume one of the forms:",
     "if N >= M,  R = ( R11 ) M  ,   or if N < M,  R = ( R11  R12 ) N,",
     "                (  0  ) N-M                         N   M-N",
     "                   M",
     "where R11 is upper triangular, and",
     "if N <= P,  T = ( 0  T12 ) N,   or if N > P,  T = ( T11 ) N-P,",
     "                 P-N  N                           ( T21 ) P",
     "                                                     P",
     "where T12 or T21 is upper triangular.",
     "In particular, if B is square and nonsingular, the GQR factorization",
     "of A and B implicitly gives the QR factorization of inv(B)*A:",
     "             inv(B)*A = Z**H * (inv(T)*R)",
     "where inv(B) denotes the inverse of the matrix B, and Z' denotes the",
     "conjugate transpose of matrix Z."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrices A and B. N >= 0."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of columns of the matrix B.  P >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,M)",
       "         On entry, the N-by-M matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(N,M)-by-M upper trapezoidal matrix R (R is",
       "         upper triangular if N >= M); the elements below the diagonal,",
       "         with the array TAUA, represent the unitary matrix Q as a",
       "         product of min(N,M) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "TAUA"=>
      ["[out]",
       "         TAUA is COMPLEX array, dimension (min(N,M))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Q (see Further Details)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,P)",
       "         On entry, the N-by-P matrix B.",
       "         On exit, if N <= P, the upper triangle of the subarray",
       "         B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T;",
       "         if N > P, the elements on and above the (N-P)-th subdiagonal",
       "         contain the N-by-P upper trapezoidal matrix T; the remaining",
       "         elements, with the array TAUB, represent the unitary",
       "         matrix Z as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "TAUB"=>
      ["[out]",
       "         TAUB is COMPLEX array, dimension (min(N,P))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Z (see Further Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N,M,P).",
       "         For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),",
       "         where NB1 is the optimal blocksize for the QR factorization",
       "         of an N-by-M matrix, NB2 is the optimal blocksize for the",
       "         RQ factorization of an N-by-P matrix, and NB3 is the optimal",
       "         blocksize for a call of CUNMQR.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ssytrd_2stage"=>
  {"summary"=>
    ["SSYTRD_2STAGE reduces a real symmetric matrix A to real symmetric",
     "tridiagonal form T by a orthogonal similarity transformation:",
     "Q1**T Q2**T* A * Q2 * Q1 = T."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  No need for the Housholder representation, ",
       "                 in particular for the second stage (Band to",
       "                 tridiagonal) and thus LHOUS2 is of size max(1, 4*N);",
       "         = 'V':  the Householder representation is needed to ",
       "                 either generate Q1 Q2 or to apply Q1 Q2, ",
       "                 then LHOUS2 is to be queried and computed.",
       "                 (NOT AVAILABLE IN THIS RELEASE)."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the band superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         internal band-diagonal matrix AB, and the elements above ",
       "         the KD superdiagonal, with the array TAU, represent the orthogonal",
       "         matrix Q1 as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and band subdiagonal of A are over-",
       "         written by the corresponding elements of the internal band-diagonal",
       "         matrix AB, and the elements below the KD subdiagonal, with",
       "         the array TAU, represent the orthogonal matrix Q1 as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (N-KD)",
       "         The scalar factors of the elementary reflectors of ",
       "         the first stage (see Further Details)."],
     "HOUS2"=>
      ["[out]",
       "         HOUS2 is REAL array, dimension LHOUS2, that",
       "         store the Householder representation of the stage2",
       "         band to tridiagonal."],
     "LHOUS2"=>
      ["[in]",
       "         LHOUS2 is INTEGER",
       "         The dimension of the array HOUS2. LHOUS2 = MAX(1, dimension)",
       "         If LWORK = -1, or LHOUS2=-1,",
       "         then a query is assumed; the routine",
       "         only calculates the optimal size of the HOUS2 array, returns",
       "         this value as the first entry of the HOUS2 array, and no error",
       "         message related to LHOUS2 is issued by XERBLA.",
       "         LHOUS2 = MAX(1, dimension) where",
       "         dimension = 4*N if VECT='N'",
       "         not available now if VECT='H'"],
     "WORK"=>["[out]", "         WORK is REAL array, dimension LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK = MAX(1, dimension)",
       "         If LWORK = -1, or LHOUS2=-1,",
       "         then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA.",
       "         LWORK = MAX(1, dimension) where",
       "         dimension   = max(stage1,stage2) + (KD+1)*N",
       "                     = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                       + max(2*KD*KD, KD*NTHREADS) ",
       "                       + (KD+1)*N ",
       "         where KD is the blocking size of the reduction,",
       "         FACTOPTNB is the blocking used by the QR or LQ",
       "         algorithm, usually FACTOPTNB=128 is a good choice",
       "         NTHREADS is the number of threads used when",
       "         openMP compilation is enabled, otherwise =1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgeevx"=>
  {"summary"=>
    ["CGEEVX computes for an N-by-N complex nonsymmetric matrix A, the",
     "eigenvalues and, optionally, the left and/or right eigenvectors.",
     "Optionally also, it computes a balancing transformation to improve",
     "the conditioning of the eigenvalues and eigenvectors (ILO, IHI,",
     "SCALE, and ABNRM), reciprocal condition numbers for the eigenvalues",
     "(RCONDE), and reciprocal condition numbers for the right",
     "eigenvectors (RCONDV).",
     "The right eigenvector v(j) of A satisfies",
     "                 A * v(j) = lambda(j) * v(j)",
     "where lambda(j) is its eigenvalue.",
     "The left eigenvector u(j) of A satisfies",
     "              u(j)**H * A = lambda(j) * u(j)**H",
     "where u(j)**H denotes the conjugate transpose of u(j).",
     "The computed eigenvectors are normalized to have Euclidean norm",
     "equal to 1 and largest component real.",
     "Balancing a matrix means permuting the rows and columns to make it",
     "more nearly upper triangular, and applying a diagonal similarity",
     "transformation D * A * D**(-1), where D is a diagonal matrix, to",
     "make its rows and columns closer in norm and the condition numbers",
     "of its eigenvalues and eigenvectors smaller.  The computed",
     "reciprocal condition numbers correspond to the balanced matrix.",
     "Permuting rows and columns will not change the condition numbers",
     "(in exact arithmetic) but diagonal scaling will.  For further",
     "explanation of balancing, see section 4.10.2 of the LAPACK",
     "Users' Guide."],
   "param"=>
    {"BALANC"=>
      ["[in]",
       "         BALANC is CHARACTER*1",
       "         Indicates how the input matrix should be diagonally scaled",
       "         and/or permuted to improve the conditioning of its",
       "         eigenvalues.",
       "         = 'N': Do not diagonally scale or permute;",
       "         = 'P': Perform permutations to make the matrix more nearly",
       "                upper triangular. Do not diagonally scale;",
       "         = 'S': Diagonally scale the matrix, ie. replace A by",
       "                D*A*D**(-1), where D is a diagonal matrix chosen",
       "                to make the rows and columns of A more equal in",
       "                norm. Do not permute;",
       "         = 'B': Both diagonally scale and permute A.",
       "         Computed reciprocal condition numbers will be for the matrix",
       "         after balancing and/or permuting. Permuting does not change",
       "         condition numbers (in exact arithmetic), but balancing does."],
     "JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N': left eigenvectors of A are not computed;",
       "         = 'V': left eigenvectors of A are computed.",
       "         If SENSE = 'E' or 'B', JOBVL must = 'V'."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N': right eigenvectors of A are not computed;",
       "         = 'V': right eigenvectors of A are computed.",
       "         If SENSE = 'E' or 'B', JOBVR must = 'V'."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': None are computed;",
       "         = 'E': Computed for eigenvalues only;",
       "         = 'V': Computed for right eigenvectors only;",
       "         = 'B': Computed for eigenvalues and right eigenvectors.",
       "         If SENSE = 'E' or 'B', both left and right eigenvectors",
       "         must also be computed (JOBVL = 'V' and JOBVR = 'V')."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten.  If JOBVL = 'V' or",
       "         JOBVR = 'V', A contains the Schur form of the balanced",
       "         version of the matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX array, dimension (N)",
       "         W contains the computed eigenvalues."],
     "VL"=>
      ["[out]",
       "         VL is COMPLEX array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order",
       "         as their eigenvalues.",
       "         If JOBVL = 'N', VL is not referenced.",
       "         u(j) = VL(:,j), the j-th column of VL."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1; if",
       "         JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is COMPLEX array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order",
       "         as their eigenvalues.",
       "         If JOBVR = 'N', VR is not referenced.",
       "         v(j) = VR(:,j), the j-th column of VR."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1; if",
       "         JOBVR = 'V', LDVR >= N."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are integer values determined when A was",
       "         balanced.  The balanced A(i,j) = 0 if I > J and",
       "         J = 1,...,ILO-1 or I = IHI+1,...,N."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         when balancing A.  If P(j) is the index of the row and column",
       "         interchanged with row and column j, and D(j) is the scaling",
       "         factor applied to row and column j, then",
       "         SCALE(J) = P(J),    for J = 1,...,ILO-1",
       "                  = D(J),    for J = ILO,...,IHI",
       "                  = P(J)     for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "ABNRM"=>
      ["[out]",
       "         ABNRM is REAL",
       "         The one-norm of the balanced matrix (the maximum",
       "         of the sum of absolute values of elements of any column)."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is REAL array, dimension (N)",
       "         RCONDE(j) is the reciprocal condition number of the j-th",
       "         eigenvalue."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is REAL array, dimension (N)",
       "         RCONDV(j) is the reciprocal condition number of the j-th",
       "         right eigenvector."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  If SENSE = 'N' or 'E',",
       "         LWORK >= max(1,2*N), and if SENSE = 'V' or 'B',",
       "         LWORK >= N*N+2*N.",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the QR algorithm failed to compute all the",
       "               eigenvalues, and no eigenvectors or condition numbers",
       "               have been computed; elements 1:ILO-1 and i+1:N of W",
       "               contain eigenvalues which have converged."]}},
 "zgemlqt"=>
  {"summary"=>
    ["ZGEMQRT overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q C            C Q",
     "TRANS = 'C':   Q**C C            C Q**C",
     "where Q is a complex orthogonal matrix defined as the product of K",
     "elementary reflectors:",
     "      Q = H(1) H(2) . . . H(K) = I - V C V**C",
     "generated using the compact WY representation as returned by ZGELQT.",
     "Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**C from the Left;",
       "         = 'R': apply Q or Q**C from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**C."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size used for the storage of T.  K >= MB >= 1.",
       "         This must be the same value of MB used to generate T",
       "         in DGELQT."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension (LDV,K)",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGELQT in the first K rows of its array argument A."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by DGELQT, stored as a MB-by-M matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q C, Q**C C, C Q**C or C Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array. The dimension of",
       "         WORK is N*MB if SIDE = 'L', or  M*MB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dstegr"=>
  {"summary"=>
    ["DSTEGR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix T. Any such unreduced matrix has",
     "a well defined set of pairwise different real eigenvalues, the corresponding",
     "real eigenvectors are pairwise orthogonal.",
     "The spectrum may be computed either completely or partially by specifying",
     "either an interval (VL,VU] or a range of indices IL:IU for the desired",
     "eigenvalues.",
     "DSTEGR is a compatibility wrapper around the improved DSTEMR routine.",
     "See DSTEMR for further details.",
     "One important change is that the ABSTOL parameter no longer provides any",
     "benefit and hence is no longer used.",
     "Note : DSTEGR and DSTEMR work only on machines which follow",
     "IEEE-754 floating-point standard in their handling of infinities and",
     "NaNs.  Normal execution may create these exceptiona values and hence",
     "may abort due to a floating point exception in environments which",
     "do not conform to the IEEE-754 standard."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal matrix",
       "         T. On exit, D is overwritten."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the tridiagonal",
       "         matrix T in elements 1 to N-1 of E. E(N) need not be set on",
       "         input, but is used internally as workspace.",
       "         On exit, E is overwritten."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         Unused.  Was the absolute error tolerance for the",
       "         eigenvalues/eigenvectors in previous versions."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', and if INFO = 0, then the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix T",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used.",
       "         Supplying N columns is always safe."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', then LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER ARRAY, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th computed eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is relevant in the case when the matrix",
       "         is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal",
       "         (and minimal) LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,18*N)",
       "         if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (LIWORK)",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N)",
       "         if the eigenvectors are desired, and LIWORK >= max(1,8*N)",
       "         if only the eigenvalues are to be computed.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = 1X, internal error in DLARRE,",
       "               if INFO = 2X, internal error in DLARRV.",
       "               Here, the digit X = ABS( IINFO ) < 10, where IINFO is",
       "               the nonzero error code returned by DLARRE or",
       "               DLARRV, respectively."]}},
 "ctrsen"=>
  {"summary"=>
    ["CTRSEN reorders the Schur factorization of a complex matrix",
     "A = Q*T*Q**H, so that a selected cluster of eigenvalues appears in",
     "the leading positions on the diagonal of the upper triangular matrix",
     "T, and the leading columns of Q form an orthonormal basis of the",
     "corresponding right invariant subspace.",
     "Optionally the routine computes the reciprocal condition numbers of",
     "the cluster of eigenvalues and/or the invariant subspace."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for the",
       "         cluster of eigenvalues (S) or the invariant subspace (SEP):",
       "         = 'N': none;",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for invariant subspace only (SEP);",
       "         = 'B': for both eigenvalues and invariant subspace (S and",
       "                SEP)."],
     "COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'V': update the matrix Q of Schur vectors;",
       "         = 'N': do not update Q."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         SELECT specifies the eigenvalues in the selected cluster. To",
       "         select the j-th eigenvalue, SELECT(j) must be set to .TRUE.."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in,out]",
       "         T is COMPLEX array, dimension (LDT,N)",
       "         On entry, the upper triangular matrix T.",
       "         On exit, T is overwritten by the reordered matrix T, with the",
       "         selected eigenvalues as the leading diagonal elements."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDQ,N)",
       "         On entry, if COMPQ = 'V', the matrix Q of Schur vectors.",
       "         On exit, if COMPQ = 'V', Q has been postmultiplied by the",
       "         unitary transformation matrix which reorders T; the leading M",
       "         columns of Q form an orthonormal basis for the specified",
       "         invariant subspace.",
       "         If COMPQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= 1; and if COMPQ = 'V', LDQ >= N."],
     "W"=>
      ["[out]",
       "         W is COMPLEX array, dimension (N)",
       "         The reordered eigenvalues of T, in the same order as they",
       "         appear on the diagonal of T."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The dimension of the specified invariant subspace.",
       "         0 <= M <= N."],
     "S"=>
      ["[out]",
       "         S is REAL",
       "         If JOB = 'E' or 'B', S is a lower bound on the reciprocal",
       "         condition number for the selected cluster of eigenvalues.",
       "         S cannot underestimate the true reciprocal condition number",
       "         by more than a factor of sqrt(N). If M = 0 or N, S = 1.",
       "         If JOB = 'N' or 'V', S is not referenced."],
     "SEP"=>
      ["[out]",
       "         SEP is REAL",
       "         If JOB = 'V' or 'B', SEP is the estimated reciprocal",
       "         condition number of the specified invariant subspace. If",
       "         M = 0 or N, SEP = norm(T).",
       "         If JOB = 'N' or 'E', SEP is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If JOB = 'N', LWORK >= 1;",
       "         if JOB = 'E', LWORK = max(1,M*(N-M));",
       "         if JOB = 'V' or 'B', LWORK >= max(1,2*M*(N-M)).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dspsv"=>
  {"summary"=>
    ["DSPSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix stored in packed format and X",
     "and B are N-by-NRHS matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, D is symmetric and block diagonal with 1-by-1",
     "and 2-by-2 diagonal blocks.  The factored form of A is then used to",
     "solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L from the factorization",
       "         A = U*D*U**T or A = L*D*L**T as computed by DSPTRF, stored as",
       "         a packed triangular matrix in the same storage format as A."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by DSPTRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, so the solution could not be",
       "               computed."]}},
 "dbbcsd"=>
  {"summary"=>
    ["DBBCSD computes the CS decomposition of an orthogonal matrix in",
     "bidiagonal-block form,",
     "    [ B11 | B12 0  0 ]",
     "    [  0  |  0 -I  0 ]",
     "X = [----------------]",
     "    [ B21 | B22 0  0 ]",
     "    [  0  |  0  0  I ]",
     "                              [  C | -S  0  0 ]",
     "                  [ U1 |    ] [  0 |  0 -I  0 ] [ V1 |    ]**T",
     "                = [---------] [---------------] [---------]   .",
     "                  [    | U2 ] [  S |  C  0  0 ] [    | V2 ]",
     "                              [  0 |  0  0  I ]",
     "X is M-by-M, its top-left block is P-by-Q, and Q must be no larger",
     "than P, M-P, or M-Q. (If Q is not the smallest index, then X must be",
     "transposed and/or permuted. This can be done in constant time using",
     "the TRANS and SIGNS options. See DORCSD for details.)",
     "The bidiagonal matrices B11, B12, B21, and B22 are represented",
     "implicitly by angles THETA(1:Q) and PHI(1:Q-1).",
     "The orthogonal matrices U1, U2, V1T, and V2T are input/output.",
     "The input matrices are pre- or post-multiplied by the appropriate",
     "singular vector matrices."],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is updated;",
       "         otherwise:  U1 is not updated."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is updated;",
       "         otherwise:  U2 is not updated."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is updated;",
       "         otherwise:  V1T is not updated."],
     "JOBV2T"=>
      ["[in]",
       "         JOBV2T is CHARACTER",
       "         = 'Y':      V2T is updated;",
       "         otherwise:  V2T is not updated."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X, the orthogonal matrix in",
       "         bidiagonal-block form."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in the top-left block of X. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in the top-left block of X.",
       "         0 <= Q <= MIN(P,M-P,M-Q)."],
     "THETA"=>
      ["[in,out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "         On entry, the angles THETA(1),...,THETA(Q) that, along with",
       "         PHI(1), ...,PHI(Q-1), define the matrix in bidiagonal-block",
       "         form. On exit, the angles whose cosines and sines define the",
       "         diagonal blocks in the CS decomposition."],
     "PHI"=>
      ["[in,out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "         The angles PHI(1),...,PHI(Q-1) that, along with THETA(1),...,",
       "         THETA(Q), define the matrix in bidiagonal-block form."],
     "U1"=>
      ["[in,out]",
       "         U1 is DOUBLE PRECISION array, dimension (LDU1,P)",
       "         On entry, a P-by-P matrix. On exit, U1 is postmultiplied",
       "         by the left singular vector matrix common to [ B11 ; 0 ] and",
       "         [ B12 0 0 ; 0 -I 0 0 ]."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of the array U1, LDU1 >= MAX(1,P)."],
     "U2"=>
      ["[in,out]",
       "         U2 is DOUBLE PRECISION array, dimension (LDU2,M-P)",
       "         On entry, an (M-P)-by-(M-P) matrix. On exit, U2 is",
       "         postmultiplied by the left singular vector matrix common to",
       "         [ B21 ; 0 ] and [ B22 0 0 ; 0 0 I ]."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of the array U2, LDU2 >= MAX(1,M-P)."],
     "V1T"=>
      ["[in,out]",
       "         V1T is DOUBLE PRECISION array, dimension (LDV1T,Q)",
       "         On entry, a Q-by-Q matrix. On exit, V1T is premultiplied",
       "         by the transpose of the right singular vector",
       "         matrix common to [ B11 ; 0 ] and [ B21 ; 0 ]."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of the array V1T, LDV1T >= MAX(1,Q)."],
     "V2T"=>
      ["[in,out]",
       "         V2T is DOUBLE PRECISION array, dimenison (LDV2T,M-Q)",
       "         On entry, an (M-Q)-by-(M-Q) matrix. On exit, V2T is",
       "         premultiplied by the transpose of the right",
       "         singular vector matrix common to [ B12 0 0 ; 0 -I 0 ] and",
       "         [ B22 0 0 ; 0 0 I ]."],
     "LDV2T"=>
      ["[in]",
       "         LDV2T is INTEGER",
       "         The leading dimension of the array V2T, LDV2T >= MAX(1,M-Q)."],
     "B11D"=>
      ["[out]",
       "         B11D is DOUBLE PRECISION array, dimension (Q)",
       "         When DBBCSD converges, B11D contains the cosines of THETA(1),",
       "         ..., THETA(Q). If DBBCSD fails to converge, then B11D",
       "         contains the diagonal of the partially reduced top-left",
       "         block."],
     "B11E"=>
      ["[out]",
       "         B11E is DOUBLE PRECISION array, dimension (Q-1)",
       "         When DBBCSD converges, B11E contains zeros. If DBBCSD fails",
       "         to converge, then B11E contains the superdiagonal of the",
       "         partially reduced top-left block."],
     "B12D"=>
      ["[out]",
       "         B12D is DOUBLE PRECISION array, dimension (Q)",
       "         When DBBCSD converges, B12D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If DBBCSD fails to converge, then",
       "         B12D contains the diagonal of the partially reduced top-right",
       "         block."],
     "B12E"=>
      ["[out]",
       "         B12E is DOUBLE PRECISION array, dimension (Q-1)",
       "         When DBBCSD converges, B12E contains zeros. If DBBCSD fails",
       "         to converge, then B12E contains the subdiagonal of the",
       "         partially reduced top-right block."],
     "B21D"=>
      ["[out]",
       "         B21D is DOUBLE PRECISION  array, dimension (Q)",
       "         When DBBCSD converges, B21D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If DBBCSD fails to converge, then",
       "         B21D contains the diagonal of the partially reduced bottom-left",
       "         block."],
     "B21E"=>
      ["[out]",
       "         B21E is DOUBLE PRECISION  array, dimension (Q-1)",
       "         When DBBCSD converges, B21E contains zeros. If DBBCSD fails",
       "         to converge, then B21E contains the subdiagonal of the",
       "         partially reduced bottom-left block."],
     "B22D"=>
      ["[out]",
       "         B22D is DOUBLE PRECISION  array, dimension (Q)",
       "         When DBBCSD converges, B22D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If DBBCSD fails to converge, then",
       "         B22D contains the diagonal of the partially reduced bottom-right",
       "         block."],
     "B22E"=>
      ["[out]",
       "         B22E is DOUBLE PRECISION  array, dimension (Q-1)",
       "         When DBBCSD converges, B22E contains zeros. If DBBCSD fails",
       "         to converge, then B22E contains the subdiagonal of the",
       "         partially reduced bottom-right block."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= MAX(1,8*Q).",
       "         If LWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the WORK array,",
       "         returns this value as the first entry of the work array, and",
       "         no error message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if DBBCSD did not converge, INFO specifies the number",
       "               of nonzero entries in PHI, and B11D, B11E, etc.,",
       "               contain the partially reduced matrix."]}},
 "zla_gerpvgrw"=>
  {"summary"=>
    ["ZLA_GERPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A. NCOLS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by ZGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."]}},
 "clantb"=>
  {"summary"=>
    ["CLANTB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n triangular band matrix A,  with ( k + 1 ) diagonals.",
     "   CLANTB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANTB as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANTB is",
       "         set to zero."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals of the matrix A if UPLO = 'L'.",
       "         K >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first k+1 rows of AB.  The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)   = A(i,j) for j<=i<=min(n,j+k).",
       "         Note that when DIAG = 'U', the elements of the array AB",
       "         corresponding to the diagonal elements of the matrix A are",
       "         not referenced, but are assumed to be one."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= K+1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "cgglse"=>
  {"summary"=>
    ["CGGLSE solves the linear equality-constrained least squares (LSE)",
     "problem:",
     "        minimize || c - A*x ||_2   subject to   B*x = d",
     "where A is an M-by-N matrix, B is a P-by-N matrix, c is a given",
     "M-vector, and d is a given P-vector. It is assumed that",
     "P <= N <= M+P, and",
     "         rank(B) = P and  rank( (A) ) = N.",
     "                              ( (B) )",
     "These conditions ensure that the LSE problem has a unique solution,",
     "which is obtained using a generalized RQ factorization of the",
     "matrices (B, A) given by",
     "   B = (0 R)*Q,   A = Z*T*Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B. N >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B. 0 <= P <= N <= M+P."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, the upper triangle of the subarray B(1:P,N-P+1:N)",
       "         contains the P-by-P upper triangular matrix R."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (M)",
       "         On entry, C contains the right hand side vector for the",
       "         least squares part of the LSE problem.",
       "         On exit, the residual sum of squares for the solution",
       "         is given by the sum of squares of elements N-P+1 to M of",
       "         vector C."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX array, dimension (P)",
       "         On entry, D contains the right hand side vector for the",
       "         constrained equation.",
       "         On exit, D is destroyed."],
     "X"=>
      ["[out]",
       "         X is COMPLEX array, dimension (N)",
       "         On exit, X is the solution of the LSE problem."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M+N+P).",
       "         For optimum performance LWORK >= P+min(M,N)+max(M,N)*NB,",
       "         where NB is an upper bound for the optimal blocksizes for",
       "         CGEQRF, CGERQF, CUNMQR and CUNMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the upper triangular factor R associated with B in the",
       "               generalized RQ factorization of the pair (B, A) is",
       "               singular, so that rank(B) < P; the least squares",
       "               solution could not be computed.",
       "         = 2:  the (N-P) by (N-P) part of the upper trapezoidal factor",
       "               T associated with A in the generalized RQ factorization",
       "               of the pair (B, A) is singular, so that",
       "               rank( (A) ) < N; the least squares solution could not",
       "                   ( (B) )",
       "               be computed."]}},
 "zlacrm"=>
  {"summary"=>
    ["ZLACRM performs a very simple matrix-matrix multiplication:",
     "         C := A * B,",
     "where A is M by N and complex; B is N by N and real;",
     "C is M by N and complex."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A and of the matrix C.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns and rows of the matrix B and",
       "         the number of columns of the matrix C.",
       "         N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, A contains the M by N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >=max(1,M)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, B contains the N by N matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >=max(1,N)."],
     "C"=>
      ["[out]",
       "         C is COMPLEX*16 array, dimension (LDC, N)",
       "         On exit, C contains the M by N matrix C."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >=max(1,N)."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (2*M*N)"]}},
 "slaqsy"=>
  {"summary"=>
    ["SLAQSY equilibrates a symmetric matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if EQUED = 'Y', the equilibrated matrix:",
       "         diag(S) * A * diag(S)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is REAL",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "dtplqt"=>
  {"summary"=>
    ["DTPLQT computes a blocked LQ factorization of a real",
     "\"triangular-pentagonal\" matrix C, which is composed of a",
     "triangular block A and pentagonal block B, using the compact",
     "WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B, and the order of the",
       "         triangular matrix A.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the lower trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.  M >= MB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the lower triangular N-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the lower triangular matrix L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first N-L columns",
       "         are rectangular, and the last L columns are lower trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         The lower triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (MB*M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "spttrf"=>
  {"summary"=>
    ["SPTTRF computes the L*D*L**T factorization of a real symmetric",
     "positive definite tridiagonal matrix A.  The factorization may also",
     "be regarded as having the form A = U**T*D*U."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.  On exit, the n diagonal elements of the diagonal matrix",
       "         D from the L*D*L**T factorization of A."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A.  On exit, the (n-1) subdiagonal elements of the",
       "         unit bidiagonal factor L from the L*D*L**T factorization of A.",
       "         E can also be regarded as the superdiagonal of the unit",
       "         bidiagonal factor U from the U**T*D*U factorization of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite; if k < N, the factorization could not",
       "              be completed, while if k = N, the factorization was",
       "              completed, but D(N) <= 0."]}},
 "slalsa"=>
  {"summary"=>
    ["SLALSA is an itermediate step in solving the least squares problem",
     "by computing the SVD of the coefficient matrix in compact form (The",
     "singular vectors are computed as products of simple orthorgonal",
     "matrices.).",
     "If ICOMPQ = 0, SLALSA applies the inverse of the left singular vector",
     "matrix of an upper bidiagonal matrix to the right hand side; and if",
     "ICOMPQ = 1, SLALSA applies the right singular vector matrix to the",
     "right hand side. The singular vector matrices were generated in",
     "compact form by SLALSA."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether the left or the right singular vector",
       "        matrix is involved.",
       "        = 0: Left singular vector matrix",
       "        = 1: Right singular vector matrix"],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        The maximum size of the subproblems at the bottom of the",
       "        computation tree."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The row and column dimensions of the upper bidiagonal matrix."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B and BX. NRHS must be at least 1."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension ( LDB, NRHS )",
       "        On input, B contains the right hand sides of the least",
       "        squares problem in rows 1 through M.",
       "        On output, B contains the solution X in rows 1 through N."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B in the calling subprogram.",
       "        LDB must be at least max(1,MAX( M, N ) )."],
     "BX"=>
      ["[out]",
       "         BX is REAL array, dimension ( LDBX, NRHS )",
       "        On exit, the result of applying the left or right singular",
       "        vector matrix to B."],
     "LDBX"=>
      ["[in]",
       "         LDBX is INTEGER",
       "        The leading dimension of BX."],
     "U"=>
      ["[in]",
       "         U is REAL array, dimension ( LDU, SMLSIZ ).",
       "        On entry, U contains the left singular vector matrices of all",
       "        subproblems at the bottom level."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER, LDU = > N.",
       "        The leading dimension of arrays U, VT, DIFL, DIFR,",
       "        POLES, GIVNUM, and Z."],
     "VT"=>
      ["[in]",
       "         VT is REAL array, dimension ( LDU, SMLSIZ+1 ).",
       "        On entry, VT**T contains the right singular vector matrices of",
       "        all subproblems at the bottom level."],
     "K"=>["[in]", "         K is INTEGER array, dimension ( N )."],
     "DIFL"=>
      ["[in]",
       "         DIFL is REAL array, dimension ( LDU, NLVL ).",
       "        where NLVL = INT(log_2 (N/(SMLSIZ+1))) + 1."],
     "DIFR"=>
      ["[in]",
       "         DIFR is REAL array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, DIFL(*, I) and DIFR(*, 2 * I -1) record",
       "        distances between singular values on the I-th level and",
       "        singular values on the (I -1)-th level, and DIFR(*, 2 * I)",
       "        record the normalizing factors of the right singular vectors",
       "        matrices of subproblems on I-th level."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension ( LDU, NLVL ).",
       "        On entry, Z(1, I) contains the components of the deflation-",
       "        adjusted updating row vector for subproblems on the I-th",
       "        level."],
     "POLES"=>
      ["[in]",
       "         POLES is REAL array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, POLES(*, 2 * I -1: 2 * I) contains the new and old",
       "        singular values involved in the secular equations on the I-th",
       "        level."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER array, dimension ( N ).",
       "        On entry, GIVPTR( I ) records the number of Givens",
       "        rotations performed on the I-th problem on the computation",
       "        tree."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 * NLVL ).",
       "        On entry, for each I, GIVCOL(*, 2 * I - 1: 2 * I) records the",
       "        locations of Givens rotations performed on the I-th level on",
       "        the computation tree."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER, LDGCOL = > N.",
       "        The leading dimension of arrays GIVCOL and PERM."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension ( LDGCOL, NLVL ).",
       "        On entry, PERM(*, I) records permutations done on the I-th",
       "        level of the computation tree."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is REAL array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, GIVNUM(*, 2 *I -1 : 2 * I) records the C- and S-",
       "        values of Givens rotations performed on the I-th level on the",
       "        computation tree."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension ( N ).",
       "        On entry, if the I-th subproblem is not square,",
       "        C( I ) contains the C-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension ( N ).",
       "        On entry, if the I-th subproblem is not square,",
       "        S( I ) contains the S-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array.",
       "        The dimension must be at least N."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array.",
       "        The dimension must be at least 3 * N"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dgelqf"=>
  {"summary"=>
    ["DGELQF computes an LQ factorization of a real M-by-N matrix A:",
     "A = L * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the m-by-min(m,n) lower trapezoidal matrix L (L is",
       "         lower triangular if m <= n); the elements above the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "csysv_rook"=>
  {"summary"=>
    ["CSYSV_ROOK computes the solution to a complex system of linear",
     "equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "CSYTRF_ROOK is called to compute the factorization of a complex",
     "symmetric matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal",
     "pivoting method.",
     "The factored form of A is then used to solve the system",
     "of equations A * X = B by calling CSYTRS_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**T or A = L*D*L**T as computed by",
       "         CSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D,",
       "         as determined by CSYTRF_ROOK.",
       "         If UPLO = 'U':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k-1 and -IPIV(k-1) were inerchaged,",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k+1 and -IPIV(k+1) were inerchaged,",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         CSYTRF_ROOK.",
       "         TRS will be done with Level 2 BLAS",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "zsytri2"=>
  {"summary"=>
    ["ZSYTRI2 computes the inverse of a COMPLEX*16 symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "ZSYTRF. ZSYTRI2 sets the LEADING DIMENSION of the workspace",
     "before calling ZSYTRI2X that actually computes the inverse."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by ZSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NB structure of D",
       "         as determined by ZSYTRF."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (N+NB+1)*(NB+3)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         WORK is size >= (N+NB+1)*(NB+3)",
       "         If LDWORK = -1, then a workspace query is assumed; the routine",
       "          calculates:",
       "             - the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array,",
       "             - and no error message related to LDWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "dhseqr"=>
  {"summary"=>
    ["   DHSEQR computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**T, where T is an upper quasi-triangular matrix (the",
     "   Schur form), and Z is the orthogonal matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input orthogonal",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the orthogonal matrix Q:  A = Q*H*Q**T = (QZ)*T*(QZ)**T."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "          = 'E':  compute eigenvalues only;",
       "          = 'S':  compute eigenvalues and the Schur form T."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "          = 'N':  no Schur vectors are computed;",
       "          = 'I':  Z is initialized to the unit matrix and the matrix Z",
       "                  of Schur vectors of H is returned;",
       "          = 'V':  Z must contain an orthogonal matrix Q on entry, and",
       "                  the product Q*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "          set by a previous call to DGEBAL, and then passed to ZGEHRD",
       "          when the matrix output by DGEBAL is reduced to Hessenberg",
       "          form. Otherwise ILO and IHI should be set to 1 and N",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is DOUBLE PRECISION array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and JOB = 'S', then H contains the",
       "          upper quasi-triangular matrix T from the Schur decomposition",
       "          (the Schur form); 2-by-2 diagonal blocks (corresponding to",
       "          complex conjugate pairs of eigenvalues) are returned in",
       "          standard form, with H(i,i) = H(i+1,i+1) and",
       "          H(i+1,i)*H(i,i+1).LT.0. If INFO = 0 and JOB = 'E', the",
       "          contents of H are unspecified on exit.  (The output value of",
       "          H when INFO.GT.0 is given under the description of INFO",
       "          below.)",
       "          Unlike earlier versions of DHSEQR, this subroutine may",
       "          explicitly H(i,j) = 0 for i.GT.j and j = 1, 2, ... ILO-1",
       "          or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "WR"=>["[out]", "         WR is DOUBLE PRECISION array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is DOUBLE PRECISION array, dimension (N)",
       "          The real and imaginary parts, respectively, of the computed",
       "          eigenvalues. If two eigenvalues are computed as a complex",
       "          conjugate pair, they are stored in consecutive elements of",
       "          WR and WI, say the i-th and (i+1)th, with WI(i) .GT. 0 and",
       "          WI(i+1) .LT. 0. If JOB = 'S', the eigenvalues are stored in",
       "          the same order as on the diagonal of the Schur form returned",
       "          in H, with WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2",
       "          diagonal block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and",
       "          WI(i+1) = -WI(i)."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ,N)",
       "          If COMPZ = 'N', Z is not referenced.",
       "          If COMPZ = 'I', on entry Z need not be set and on exit,",
       "          if INFO = 0, Z contains the orthogonal matrix Z of the Schur",
       "          vectors of H.  If COMPZ = 'V', on entry Z must contain an",
       "          N-by-N matrix Q, which is assumed to be equal to the unit",
       "          matrix except for the submatrix Z(ILO:IHI,ILO:IHI). On exit,",
       "          if INFO = 0, Z contains Q*Z.",
       "          Normally Q is the orthogonal matrix generated by DORGHR",
       "          after the call to DGEHRD which formed the Hessenberg matrix",
       "          H. (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if COMPZ = 'I' or",
       "          COMPZ = 'V', then LDZ.GE.MAX(1,N).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LWORK)",
       "          On exit, if INFO = 0, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient and delivers very good and sometimes",
       "          optimal performance.  However, LWORK as large as 11*N",
       "          may be required for optimal performance.  A workspace",
       "          query is recommended to determine the optimal workspace",
       "          size.",
       "          If LWORK = -1, then DHSEQR does a workspace query.",
       "          In this case, DHSEQR checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .LT. 0:  if INFO = -i, the i-th argument had an illegal",
       "                   value",
       "          .GT. 0:  if INFO = i, DHSEQR failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and JOB = 'E', then on exit, the",
       "               remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and JOB   = 'S', then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is an orthogonal matrix.  The final",
       "               value of H is upper Hessenberg and quasi-triangular",
       "               in rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and COMPZ = 'V', then on exit",
       "                 (final value of Z)  =  (initial value of Z)*U",
       "               where U is the orthogonal matrix in (*) (regard-",
       "               less of the value of JOB.)",
       "               If INFO .GT. 0 and COMPZ = 'I', then on exit",
       "                     (final value of Z)  = U",
       "               where U is the orthogonal matrix in (*) (regard-",
       "               less of the value of JOB.)",
       "               If INFO .GT. 0 and COMPZ = 'N', then Z is not",
       "               accessed."]}},
 "slaswp"=>
  {"summary"=>
    ["SLASWP performs a series of row interchanges on the matrix A.",
     "One row interchange is initiated for each of rows K1 through K2 of A."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the matrix of column dimension N to which the row",
       "         interchanges will be applied.",
       "         On exit, the permuted matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A."],
     "K1"=>
      ["[in]",
       "         K1 is INTEGER",
       "         The first element of IPIV for which a row interchange will",
       "         be done."],
     "K2"=>
      ["[in]",
       "         K2 is INTEGER",
       "         (K2-K1+1) is the number of elements of IPIV for which a row",
       "         interchange will be done."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (K1+(K2-K1)*abs(INCX))",
       "         The vector of pivot indices. Only the elements in positions",
       "         K1 through K1+(K2-K1)*INCX of IPIV are accessed.",
       "         IPIV(K) = L implies rows K and L are to be interchanged."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of IPIV.  If IPIV",
       "         is negative, the pivots are applied in reverse order."]}},
 "sla_porpvgrw"=>
  {"summary"=>
    ["SLA_PORPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A. NCOLS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by SPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "WORK"=>["[in]", "         WORK is REAL array, dimension (2*N)"]}},
 "ssyevr"=>
  {"summary"=>
    ["SSYEVR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A.  Eigenvalues and eigenvectors can be",
     "selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues.",
     "SSYEVR first reduces the matrix A to tridiagonal form T with a call",
     "to SSYTRD.  Then, whenever possible, SSYEVR calls SSTEMR to compute",
     "the eigenspectrum using Relatively Robust Representations.  SSTEMR",
     "computes eigenvalues by the dqds algorithm, while orthogonal",
     "eigenvectors are computed from various \"good\" L D L^T representations",
     "(also known as Relatively Robust Representations). Gram-Schmidt",
     "orthogonalization is avoided as far as possible. More specifically,",
     "the various steps of the algorithm are as follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "The desired accuracy of the output can be specified by the input",
     "parameter ABSTOL.",
     "For more details, see SSTEMR's documentation and:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Note 1 : SSYEVR calls SSTEMR when the full spectrum is requested",
     "on machines which conform to the ieee-754 floating point standard.",
     "SSYEVR calls SSTEBZ and SSTEIN on non-ieee machines and",
     "when partial spectrum requests are made.",
     "Normal execution of SSTEMR may create NaNs and infinities and",
     "hence may abort due to a floating point exception in environments",
     "which do not handle NaNs and infinities in the ieee standard default",
     "manner."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found.",
       "         For RANGE = 'V' or 'I' and IU - IL < N - 1, SSTEBZ and",
       "         SSTEIN are called"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3.",
       "         If high relative accuracy is important, set ABSTOL to",
       "         SLAMCH( 'Safe minimum' ).  Doing so will guarantee that",
       "         eigenvalues are computed to high relative accuracy when",
       "         possible in future releases.  The current code does not",
       "         make any guarantees about high relative accuracy, but",
       "         future releases will. See J. Barlow and J. Demmel,",
       "         \"Computing Accurate Eigensystems of Scaled Diagonally",
       "         Dominant Matrices\", LAPACK Working Note #7, for a discussion",
       "         of which matrices define their eigenvalues to high relative",
       "         accuracy."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used.",
       "         Supplying N columns is always safe."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is an output of SSTEMR (tridiagonal",
       "         matrix). The support of the eigenvectors of A is typically",
       "         1:N because of the orthogonal transformations applied by SORMTR.",
       "         Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1"],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,26*N).",
       "         For optimal efficiency, LWORK >= (NB+6)*N,",
       "         where NB is the max of the blocksize for SSYTRD and SORMTR",
       "         returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  Internal error"]}},
 "sptsv"=>
  {"summary"=>
    ["SPTSV computes the solution to a real system of linear equations",
     "A*X = B, where A is an N-by-N symmetric positive definite tridiagonal",
     "matrix, and X and B are N-by-NRHS matrices.",
     "A is factored as A = L*D*L**T, and the factored form of A is then",
     "used to solve the system of equations."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.  On exit, the n diagonal elements of the diagonal matrix",
       "         D from the factorization A = L*D*L**T."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A.  On exit, the (n-1) subdiagonal elements of the",
       "         unit bidiagonal factor L from the L*D*L**T factorization of",
       "         A.  (E can also be regarded as the superdiagonal of the unit",
       "         bidiagonal factor U from the U**T*D*U factorization of A.)"],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the solution has not been",
       "               computed.  The factorization has not been completed",
       "               unless i = N."]}},
 "cgeesx"=>
  {"summary"=>
    ["CGEESX computes for an N-by-N complex nonsymmetric matrix A, the",
     "eigenvalues, the Schur form T, and, optionally, the matrix of Schur",
     "vectors Z.  This gives the Schur factorization A = Z*T*(Z**H).",
     "Optionally, it also orders the eigenvalues on the diagonal of the",
     "Schur form so that selected eigenvalues are at the top left;",
     "computes a reciprocal condition number for the average of the",
     "selected eigenvalues (RCONDE); and computes a reciprocal condition",
     "number for the right invariant subspace corresponding to the",
     "selected eigenvalues (RCONDV).  The leading columns of Z form an",
     "orthonormal basis for this invariant subspace.",
     "For further explanation of the reciprocal condition numbers RCONDE",
     "and RCONDV, see Section 4.10 of the LAPACK Users' Guide (where",
     "these quantities are called s and sep respectively).",
     "A complex matrix is in Schur form if it is upper triangular."],
   "param"=>
    {"JOBVS"=>
      ["[in]",
       "         JOBVS is CHARACTER*1",
       "         = 'N': Schur vectors are not computed;",
       "         = 'V': Schur vectors are computed."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the Schur form.",
       "         = 'N': Eigenvalues are not ordered;",
       "         = 'S': Eigenvalues are ordered (see SELECT)."],
     "SELECT"=>
      ["[in]",
       "         SELECT is a LOGICAL FUNCTION of one COMPLEX argument",
       "         SELECT must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'S', SELECT is used to select eigenvalues to order",
       "         to the top left of the Schur form.",
       "         If SORT = 'N', SELECT is not referenced.",
       "         An eigenvalue W(j) is selected if SELECT(W(j)) is true."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': None are computed;",
       "         = 'E': Computed for average of selected eigenvalues only;",
       "         = 'V': Computed for selected right invariant subspace only;",
       "         = 'B': Computed for both.",
       "         If SENSE = 'E', 'V' or 'B', SORT must equal 'S'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A is overwritten by its Schur form T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues for which",
       "                        SELECT is true."],
     "W"=>
      ["[out]",
       "         W is COMPLEX array, dimension (N)",
       "         W contains the computed eigenvalues, in the same order",
       "         that they appear on the diagonal of the output Schur form T."],
     "VS"=>
      ["[out]",
       "         VS is COMPLEX array, dimension (LDVS,N)",
       "         If JOBVS = 'V', VS contains the unitary matrix Z of Schur",
       "         vectors.",
       "         If JOBVS = 'N', VS is not referenced."],
     "LDVS"=>
      ["[in]",
       "         LDVS is INTEGER",
       "         The leading dimension of the array VS.  LDVS >= 1, and if",
       "         JOBVS = 'V', LDVS >= N."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is REAL",
       "         If SENSE = 'E' or 'B', RCONDE contains the reciprocal",
       "         condition number for the average of the selected eigenvalues.",
       "         Not referenced if SENSE = 'N' or 'V'."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is REAL",
       "         If SENSE = 'V' or 'B', RCONDV contains the reciprocal",
       "         condition number for the selected right invariant subspace.",
       "         Not referenced if SENSE = 'N' or 'E'."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,2*N).",
       "         Also, if SENSE = 'E' or 'V' or 'B', LWORK >= 2*SDIM*(N-SDIM),",
       "         where SDIM is the number of selected eigenvalues computed by",
       "         this routine.  Note that 2*SDIM*(N-SDIM) <= N*N/2. Note also",
       "         that an error is only returned if LWORK < max(1,2*N), but if",
       "         SENSE = 'E' or 'V' or 'B' this may not be large enough.",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates upper bound on the optimal size of the",
       "         array WORK, returns this value as the first entry of the WORK",
       "         array, and no error message related to LWORK is issued by",
       "         XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value.",
       "         > 0: if INFO = i, and i is",
       "            <= N: the QR algorithm failed to compute all the",
       "                  eigenvalues; elements 1:ILO-1 and i+1:N of W",
       "                  contain those eigenvalues which have converged; if",
       "                  JOBVS = 'V', VS contains the transformation which",
       "                  reduces A to its partially converged Schur form.",
       "            = N+1: the eigenvalues could not be reordered because some",
       "                  eigenvalues were too close to separate (the problem",
       "                  is very ill-conditioned);",
       "            = N+2: after reordering, roundoff changed values of some",
       "                  complex eigenvalues so that leading eigenvalues in",
       "                  the Schur form no longer satisfy SELECT=.TRUE.  This",
       "                  could also be caused by underflow due to scaling."]}},
 "clargv"=>
  {"summary"=>
    ["CLARGV generates a vector of complex plane rotations with real",
     "cosines, determined by elements of the complex vectors x and y.",
     "For i = 1,2,...,n",
     "   (        c(i)   s(i) ) ( x(i) ) = ( r(i) )",
     "   ( -conjg(s(i))  c(i) ) ( y(i) ) = (   0  )",
     "   where c(i)**2 + ABS(s(i))**2 = 1",
     "The following conventions are used (these are the same as in CLARTG,",
     "but differ from the BLAS1 routine CROTG):",
     "   If y(i)=0, then c(i)=1 and s(i)=0.",
     "   If x(i)=0, then c(i)=0 and s(i) is chosen so that r(i) is real."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be generated."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (1+(N-1)*INCX)",
       "         On entry, the vector x.",
       "         On exit, x(i) is overwritten by r(i), for i = 1,...,n."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension (1+(N-1)*INCY)",
       "         On entry, the vector y.",
       "         On exit, the sines of the plane rotations."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between elements of Y. INCY > 0."],
     "C"=>
      ["[out]",
       "         C is REAL array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C. INCC > 0."]}},
 "zlaqhe"=>
  {"summary"=>
    ["ZLAQHE equilibrates a Hermitian matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if EQUED = 'Y', the equilibrated matrix:",
       "         diag(S) * A * diag(S)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is DOUBLE PRECISION",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "dgehd2"=>
  {"summary"=>
    ["DGEHD2 reduces a real general matrix A to upper Hessenberg form H by",
     "an orthogonal similarity transformation:  Q**T * A * Q = H ."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that A is already upper triangular in rows",
       "         and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "         set by a previous call to DGEBAL; otherwise they should be",
       "         set to 1 and N respectively. See Further Details.",
       "         1 <= ILO <= IHI <= max(1,N)."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the n by n general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         elements below the first subdiagonal, with the array TAU,",
       "         represent the orthogonal matrix Q as a product of elementary",
       "         reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "cla_gercond_c"=>
  {"summary"=>
    ["   CLA_GERCOND_C computes the infinity norm condition number of",
     "   op(A) * inv(diag(C)) where C is a REAL vector."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by CGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by CGETRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The vector C in the formula op(A) * inv(diag(C))."],
     "CAPPLY"=>
      ["[in]",
       "         CAPPLY is LOGICAL",
       "    If .TRUE. then access the vector C in the formula above."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is REAL array, dimension (N).",
       "    Workspace."]}},
 "zlarfx"=>
  {"summary"=>
    ["ZLARFX applies a complex elementary reflector H to a complex m by n",
     "matrix C, from either the left or the right. H is represented in the",
     "form",
     "      H = I - tau * v * v**H",
     "where tau is a complex scalar and v is a complex vector.",
     "If tau = 0, then H is taken to be the unit matrix",
     "This version uses inline code if H has order < 11."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension (M) if SIDE = 'L'",
       "                                       or (N) if SIDE = 'R'",
       "         The vector v in the representation of H."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDA >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (N) if SIDE = 'L'",
       "                                           or (M) if SIDE = 'R'",
       "         WORK is not referenced if H has order < 11."]}},
 "csyequb"=>
  {"summary"=>
    ["CSYEQUB computes row and column scalings intended to equilibrate a",
     "symmetric matrix A (with respect to the Euclidean norm) and reduce",
     "its condition number. The scale factors S are computed by the BIN",
     "algorithm (see references) so that the scaled matrix B with elements",
     "B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of",
     "the smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The N-by-N symmetric matrix whose scaling factors are to be",
       "         computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is REAL",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i). If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Largest absolute value of any matrix element. If AMAX is",
       "         very close to overflow or very close to underflow, the",
       "         matrix should be scaled."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "clapll"=>
  {"summary"=>
    ["Given two column vectors X and Y, let",
     "                     A = ( X Y ).",
     "The subroutine first computes the QR factorization of A = Q*R,",
     "and then computes the SVD of the 2-by-2 upper triangular matrix R.",
     "The smaller singular value of R is returned in SSMIN, which is used",
     "as the measurement of the linear dependency of the vectors X and Y."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The length of the vectors X and Y."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (1+(N-1)*INCX)",
       "         On entry, X contains the N-vector X.",
       "         On exit, X is overwritten."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension (1+(N-1)*INCY)",
       "         On entry, Y contains the N-vector Y.",
       "         On exit, Y is overwritten."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between successive elements of Y. INCY > 0."],
     "SSMIN"=>
      ["[out]",
       "         SSMIN is REAL",
       "         The smallest singular value of the N-by-2 matrix A = ( X Y )."]}},
 "cgetri"=>
  {"summary"=>
    ["CGETRI computes the inverse of a matrix using the LU factorization",
     "computed by CGETRF.",
     "This method inverts U and then computes inv(A) by solving the system",
     "inv(A)*L = inv(U) for inv(A)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the factors L and U from the factorization",
       "         A = P*L*U as computed by CGETRF.",
       "         On exit, if INFO = 0, the inverse of the original matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from CGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO=0, then WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimal performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero; the matrix is",
       "               singular and its inverse could not be computed."]}},
 "sla_porfsx_extended"=>
  {"summary"=>
    ["SLA_PORFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by SPORFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by SPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by SPOTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is REAL array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by SLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is REAL array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is REAL array, dimension (N)",
       "    Workspace. This can be the same workspace passed for Y_TAIL."],
     "DY"=>
      ["[in]",
       "         DY is REAL array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is REAL array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is REAL",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is REAL",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to SPOTRS had an illegal",
       "            value"]}},
 "chetrd_2stage"=>
  {"summary"=>
    ["CHETRD_2STAGE reduces a complex Hermitian matrix A to real symmetric",
     "tridiagonal form T by a unitary similarity transformation:",
     "Q1**H Q2**H* A * Q2 * Q1 = T."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  No need for the Housholder representation, ",
       "                 in particular for the second stage (Band to",
       "                 tridiagonal) and thus LHOUS2 is of size max(1, 4*N);",
       "         = 'V':  the Householder representation is needed to ",
       "                 either generate Q1 Q2 or to apply Q1 Q2, ",
       "                 then LHOUS2 is to be queried and computed.",
       "                 (NOT AVAILABLE IN THIS RELEASE)."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the band superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         internal band-diagonal matrix AB, and the elements above ",
       "         the KD superdiagonal, with the array TAU, represent the unitary",
       "         matrix Q1 as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and band subdiagonal of A are over-",
       "         written by the corresponding elements of the internal band-diagonal",
       "         matrix AB, and the elements below the KD subdiagonal, with",
       "         the array TAU, represent the unitary matrix Q1 as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (N-KD)",
       "         The scalar factors of the elementary reflectors of ",
       "         the first stage (see Further Details)."],
     "HOUS2"=>
      ["[out]",
       "         HOUS2 is COMPLEX array, dimension LHOUS2, that",
       "         store the Householder representation of the stage2",
       "         band to tridiagonal."],
     "LHOUS2"=>
      ["[in]",
       "         LHOUS2 is INTEGER",
       "         The dimension of the array HOUS2. LHOUS2 = MAX(1, dimension)",
       "         If LWORK = -1, or LHOUS2=-1,",
       "         then a query is assumed; the routine",
       "         only calculates the optimal size of the HOUS2 array, returns",
       "         this value as the first entry of the HOUS2 array, and no error",
       "         message related to LHOUS2 is issued by XERBLA.",
       "         LHOUS2 = MAX(1, dimension) where",
       "         dimension = 4*N if VECT='N'",
       "         not available now if VECT='H'"],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK = MAX(1, dimension)",
       "         If LWORK = -1, or LHOUS2=-1,",
       "         then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA.",
       "         LWORK = MAX(1, dimension) where",
       "         dimension   = max(stage1,stage2) + (KD+1)*N",
       "                     = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                       + max(2*KD*KD, KD*NTHREADS) ",
       "                       + (KD+1)*N ",
       "         where KD is the blocking size of the reduction,",
       "         FACTOPTNB is the blocking used by the QR or LQ",
       "         algorithm, usually FACTOPTNB=128 is a good choice",
       "         NTHREADS is the number of threads used when",
       "         openMP compilation is enabled, otherwise =1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaed7"=>
  {"summary"=>
    ["DLAED7 computes the updated eigensystem of a diagonal",
     "matrix after modification by a rank-one symmetric matrix. This",
     "routine is used only for the eigenproblem which requires all",
     "eigenvalues and optionally eigenvectors of a dense symmetric matrix",
     "that has been reduced to tridiagonal form.  DLAED1 handles",
     "the case in which all eigenvalues and eigenvectors of a symmetric",
     "tridiagonal matrix are desired.",
     "  T = Q(in) ( D(in) + RHO * Z*Z**T ) Q**T(in) = Q(out) * D(out) * Q**T(out)",
     "   where Z = Q**Tu, u is a vector of length N with ones in the",
     "   CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.",
     "   The eigenvectors of the original matrix are stored in Q, and the",
     "   eigenvalues are in D.  The algorithm consists of three stages:",
     "      The first stage consists of deflating the size of the problem",
     "      when there are multiple eigenvalues or if there is a zero in",
     "      the Z vector.  For each such occurrence the dimension of the",
     "      secular equation problem is reduced by one.  This stage is",
     "      performed by the routine DLAED8.",
     "      The second stage consists of calculating the updated",
     "      eigenvalues. This is done by finding the roots of the secular",
     "      equation via the routine DLAED4 (as called by DLAED9).",
     "      This routine also calculates the eigenvectors of the current",
     "      problem.",
     "      The final stage consists of computing the updated eigenvectors",
     "      directly using the updated eigenvalues.  The eigenvectors for",
     "      the current problem are multiplied with the eigenvectors from",
     "      the overall problem."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "         = 0:  Compute eigenvalues only.",
       "         = 1:  Compute eigenvectors of original dense symmetric matrix",
       "               also.  On entry, Q contains the orthogonal matrix used",
       "               to reduce the original matrix to tridiagonal form."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the orthogonal matrix used to reduce",
       "        the full matrix to tridiagonal form.  QSIZ >= N if ICOMPQ = 1."],
     "TLVLS"=>
      ["[in]",
       "         TLVLS is INTEGER",
       "        The total number of merging levels in the overall divide and",
       "        conquer tree."],
     "CURLVL"=>
      ["[in]",
       "         CURLVL is INTEGER",
       "        The current level in the overall merge routine,",
       "        0 <= CURLVL <= TLVLS."],
     "CURPBM"=>
      ["[in]",
       "         CURPBM is INTEGER",
       "        The current problem in the current level in the overall",
       "        merge routine (counting from upper left to lower right)."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        On entry, the eigenvalues of the rank-1-perturbed matrix.",
       "        On exit, the eigenvalues of the repaired matrix."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ, N)",
       "        On entry, the eigenvectors of the rank-1-perturbed matrix.",
       "        On exit, the eigenvectors of the repaired tridiagonal matrix."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "INDXQ"=>
      ["[out]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        The permutation which will reintegrate the subproblem just",
       "        solved back into sorted order, i.e., D( INDXQ( I = 1, N ) )",
       "        will be in ascending order."],
     "RHO"=>
      ["[in]",
       "         RHO is DOUBLE PRECISION",
       "        The subdiagonal element used to create the rank-1",
       "        modification."],
     "CUTPNT"=>
      ["[in]",
       "         CUTPNT is INTEGER",
       "        Contains the location of the last eigenvalue in the leading",
       "        sub-matrix.  min(1,N) <= CUTPNT <= N."],
     "QSTORE"=>
      ["[in,out]",
       "         QSTORE is DOUBLE PRECISION array, dimension (N**2+1)",
       "        Stores eigenvectors of submatrices encountered during",
       "        divide and conquer, packed together. QPTR points to",
       "        beginning of the submatrices."],
     "QPTR"=>
      ["[in,out]",
       "         QPTR is INTEGER array, dimension (N+2)",
       "        List of indices pointing to beginning of submatrices stored",
       "        in QSTORE. The submatrices are numbered starting at the",
       "        bottom left of the divide and conquer tree, from left to",
       "        right and bottom to top."],
     "PRMPTR"=>
      ["[in]",
       "         PRMPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in PERM a",
       "        level's permutation is stored.  PRMPTR(i+1) - PRMPTR(i)",
       "        indicates the size of the permutation and also the size of",
       "        the full, non-deflated problem."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension (N lg N)",
       "        Contains the permutations (from deflation and sorting) to be",
       "        applied to each eigenblock."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in GIVCOL a",
       "        level's Givens rotations are stored.  GIVPTR(i+1) - GIVPTR(i)",
       "        indicates the number of Givens rotations."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension (2, N lg N)",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is DOUBLE PRECISION array, dimension (2, N lg N)",
       "        Each number indicates the S value to be used in the",
       "        corresponding Givens rotation."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (3*N+2*QSIZ*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, an eigenvalue did not converge"]}},
 "zsytf2"=>
  {"summary"=>
    ["ZSYTF2 computes the factorization of a complex symmetric matrix A",
     "using the Bunch-Kaufman diagonal pivoting method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**T is the transpose of U, and D is symmetric and",
     "block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "sgesvxx"=>
  {"summary"=>
    ["   SGESVXX uses the LU factorization to compute the solution to a",
     "   real system of linear equations  A * X = B,  where A is an",
     "   N-by-N matrix and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. SGESVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   SGESVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   SGESVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what SGESVXX would itself produce."],
   "param"=>nil},
 "cppsvx"=>
  {"summary"=>
    ["CPPSVX uses the Cholesky factorization A = U**H*U or A = L*L**H to",
     "compute the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite matrix stored in",
     "packed format and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "stpqrt"=>
  {"summary"=>
    ["STPQRT computes a blocked QR factorization of a real",
     "\"triangular-pentagonal\" matrix C, which is composed of a",
     "triangular block A and pentagonal block B, using the compact",
     "WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of the",
       "         triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the upper trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.  N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the upper triangular N-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first M-L rows",
       "         are rectangular, and the last L rows are upper trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,N)",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (NB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "stprfb"=>
  {"summary"=>
    ["STPRFB applies a real \"triangular-pentagonal\" block reflector H or its",
     "conjugate transpose H^H to a real matrix C, which is composed of two",
     "blocks A and B, either from the left or right."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H^H from the Left",
       "         = 'R': apply H or H^H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'C': apply H^H (Conjugate transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columns",
       "         = 'R': Rows"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B.",
       "         N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T, i.e. the number of elementary",
       "         reflectors whose product defines the block reflector.",
       "         K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension",
       "                               (LDV,K) if STOREV = 'C'",
       "                               (LDV,M) if STOREV = 'R' and SIDE = 'L'",
       "                               (LDV,N) if STOREV = 'R' and SIDE = 'R'",
       "         The pentagonal matrix V, which contains the elementary reflectors",
       "         H(1), H(2), ..., H(K).  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);",
       "         if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);",
       "         if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (LDT,K)",
       "         The triangular K-by-K matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.",
       "         LDT >= K."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension",
       "         (LDA,N) if SIDE = 'L' or (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         H*C or H^H*C or C*H or C*H^H.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         H*C or H^H*C or C*H or C*H^H.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension",
       "         (LDWORK,N) if SIDE = 'L',",
       "         (LDWORK,K) if SIDE = 'R'."],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= K;",
       "         if SIDE = 'R', LDWORK >= M."]}},
 "ssytrd_sy2sb"=>
  {"summary"=>
    ["SSYTRD_SY2SB reduces a real symmetric matrix A to real symmetric",
     "band-diagonal form AB by a orthogonal similarity transformation:",
     "Q**T * A * Q = AB."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the reduced matrix if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0.",
       "         The reduced matrix is stored in the array AB."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the orthogonal",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the orthogonal matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AB"=>
      ["[out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On exit, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (N-KD)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension LWORK.",
       "         On exit, if INFO = 0, or if LWORK=-1, ",
       "         WORK(1) returns the size of LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK which should be calculated",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA.",
       "         LWORK_QUERY = N*KD + N*max(KD,FACTOPTNB) + 2*KD*KD",
       "         where FACTOPTNB is the blocking used by the QR or LQ",
       "         algorithm, usually FACTOPTNB=128 is a good choice otherwise",
       "         putting LWORK=-1 will provide the size of WORK."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhpsv"=>
  {"summary"=>
    ["ZHPSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian matrix stored in packed format and X",
     "and B are N-by-NRHS matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**H,  if UPLO = 'U', or",
     "   A = L * D * L**H,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, D is Hermitian and block diagonal with 1-by-1",
     "and 2-by-2 diagonal blocks.  The factored form of A is then used to",
     "solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L from the factorization",
       "         A = U*D*U**H or A = L*D*L**H as computed by ZHPTRF, stored as",
       "         a packed triangular matrix in the same storage format as A."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by ZHPTRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, so the solution could not be",
       "               computed."]}},
 "zhegvd"=>
  {"summary"=>
    ["ZHEGVD computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be Hermitian and B is also positive definite.",
     "If eigenvectors are desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the Hermitian matrix B.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of B contains the",
       "         upper triangular part of the matrix B.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of B contains",
       "         the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.",
       "         If N <= 1,                LWORK >= 1.",
       "         If JOBZ  = 'N' and N > 1, LWORK >= N + 1.",
       "         If JOBZ  = 'V' and N > 1, LWORK >= 2*N + N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If N <= 1,                LRWORK >= 1.",
       "         If JOBZ  = 'N' and N > 1, LRWORK >= N.",
       "         If JOBZ  = 'V' and N > 1, LRWORK >= 1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK >= 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK >= 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  ZPOTRF or ZHEEVD returned an error code:",
       "            <= N:  if INFO = i and JOBZ = 'N', then the algorithm",
       "                   failed to converge; i off-diagonal elements of an",
       "                   intermediate tridiagonal form did not converge to",
       "                   zero;",
       "                   if INFO = i and JOBZ = 'V', then the algorithm",
       "                   failed to compute an eigenvalue while working on",
       "                   the submatrix lying in rows and columns INFO/(N+1)",
       "                   through mod(INFO,N+1);",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "zla_syrpvgrw"=>
  {"summary"=>
    ["ZLA_SYRPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "INFO"=>
      ["[in]",
       "         INFO is INTEGER",
       "    The value of INFO returned from ZSYTRF, .i.e., the pivot in",
       "    column INFO is exactly 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by ZSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by ZSYTRF."],
     "WORK"=>
      ["[in]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"]}},
 "sspcon"=>
  {"summary"=>
    ["SSPCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric packed matrix A using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by SSPTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by SSPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSPTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlartv"=>
  {"summary"=>
    ["ZLARTV applies a vector of complex plane rotations with real cosines",
     "to elements of the complex vectors x and y. For i = 1,2,...,n",
     "   ( x(i) ) := (        c(i)   s(i) ) ( x(i) )",
     "   ( y(i) )    ( -conjg(s(i))  c(i) ) ( y(i) )"],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be applied."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (1+(N-1)*INCX)",
       "         The vector x."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension (1+(N-1)*INCY)",
       "         The vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between elements of Y. INCY > 0."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is COMPLEX*16 array, dimension (1+(N-1)*INCC)",
       "         The sines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C and S. INCC > 0."]}},
 "dlaqge"=>
  {"summary"=>
    ["DLAQGE equilibrates a general M by N matrix A using the row and",
     "column scaling factors in the vectors R and C."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M by N matrix A.",
       "         On exit, the equilibrated matrix.  See EQUED for the form of",
       "         the equilibrated matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "R"=>
      ["[in]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         The row scale factors for A."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         The column scale factors for A."],
     "ROWCND"=>
      ["[in]",
       "         ROWCND is DOUBLE PRECISION",
       "         Ratio of the smallest R(i) to the largest R(i)."],
     "COLCND"=>
      ["[in]",
       "         COLCND is DOUBLE PRECISION",
       "         Ratio of the smallest C(i) to the largest C(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies the form of equilibration that was done.",
       "         = 'N':  No equilibration",
       "         = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "                 diag(R).",
       "         = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "                 by diag(C).",
       "         = 'B':  Both row and column equilibration, i.e., A has been",
       "                 replaced by diag(R) * A * diag(C)."]}},
 "cgelq2"=>
  {"summary"=>
    ["CGELQ2 computes an LQ factorization of a complex m by n matrix A:",
     "A = L * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the m by min(m,n) lower trapezoidal matrix L (L is",
       "         lower triangular if m <= n); the elements above the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "ssytrf_aa"=>
  {"summary"=>
    ["SSYTRF_AA computes the factorization of a real symmetric matrix A",
     "using the Aasen's algorithm.  The form of the factorization is",
     "   A = U*T*U**T  or  A = L*T*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is a symmetric tridiagonal matrix.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the tridiagonal matrix is stored in the diagonals",
       "         and the subdiagonals of A just below (or above) the diagonals,",
       "         and L is stored below (or above) the subdiaonals, when UPLO",
       "         is 'L' (or 'U')."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= MAX(1,2*N). For optimum performance",
       "         LWORK >= N*(1+NB), where NB is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "csymv"=>
  {"summary"=>
    ["CSYMV  performs the matrix-vector  operation",
     "   y := alpha*A*x + beta*y,",
     "where alpha and beta are scalars, x and y are n element vectors and",
     "A is an n by n symmetric matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array A is to be referenced as",
       "          follows:",
       "             UPLO = 'U' or 'u'   Only the upper triangular part of A",
       "                                 is to be referenced.",
       "             UPLO = 'L' or 'l'   Only the lower triangular part of A",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the order of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension ( LDA, N )",
       "          Before entry, with  UPLO = 'U' or 'u', the leading n by n",
       "          upper triangular part of the array A must contain the upper",
       "          triangular part of the symmetric matrix and the strictly",
       "          lower triangular part of A is not referenced.",
       "          Before entry, with UPLO = 'L' or 'l', the leading n by n",
       "          lower triangular part of the array A must contain the lower",
       "          triangular part of the symmetric matrix and the strictly",
       "          upper triangular part of A is not referenced.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, N ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCX ) ).",
       "          Before entry, the incremented array X must contain the N-",
       "          element vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is COMPLEX",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCY ) ).",
       "          Before entry, the incremented array Y must contain the n",
       "          element vector y. On exit, Y is overwritten by the updated",
       "          vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit."]}},
 "dormlq"=>
  {"summary"=>
    ["DORMLQ overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by DGELQF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGELQF in the first k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGELQF."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgbbrd"=>
  {"summary"=>
    ["DGBBRD reduces a real general m-by-n band matrix A to upper",
     "bidiagonal form B by an orthogonal transformation: Q**T * A * P = B.",
     "The routine computes B, and optionally forms Q or P**T, or computes",
     "Q**T*C for a given matrix C."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         Specifies whether or not the matrices Q and P**T are to be",
       "         formed.",
       "         = 'N': do not form Q or P**T;",
       "         = 'Q': form Q only;",
       "         = 'P': form P**T only;",
       "         = 'B': form both."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NCC"=>
      ["[in]",
       "         NCC is INTEGER",
       "         The number of columns of the matrix C.  NCC >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals of the matrix A. KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals of the matrix A. KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the m-by-n band matrix A, stored in rows 1 to",
       "         KL+KU+1. The j-th column of A is stored in the j-th column of",
       "         the array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl).",
       "         On exit, A is overwritten by values generated during the",
       "         reduction."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A. LDAB >= KL+KU+1."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (min(M,N)-1)",
       "         The superdiagonal elements of the bidiagonal matrix B."],
     "Q"=>
      ["[out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,M)",
       "         If VECT = 'Q' or 'B', the m-by-m orthogonal matrix Q.",
       "         If VECT = 'N' or 'P', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= max(1,M) if VECT = 'Q' or 'B'; LDQ >= 1 otherwise."],
     "PT"=>
      ["[out]",
       "         PT is DOUBLE PRECISION array, dimension (LDPT,N)",
       "         If VECT = 'P' or 'B', the n-by-n orthogonal matrix P'.",
       "         If VECT = 'N' or 'Q', the array PT is not referenced."],
     "LDPT"=>
      ["[in]",
       "         LDPT is INTEGER",
       "         The leading dimension of the array PT.",
       "         LDPT >= max(1,N) if VECT = 'P' or 'B'; LDPT >= 1 otherwise."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,NCC)",
       "         On entry, an m-by-ncc matrix C.",
       "         On exit, C is overwritten by Q**T*C.",
       "         C is not referenced if NCC = 0."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.",
       "         LDC >= max(1,M) if NCC > 0; LDC >= 1 if NCC = 0."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (2*max(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "clansp"=>
  {"summary"=>
    ["CLANSP  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex symmetric matrix A,  supplied in packed form.",
     "   CLANSP = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANSP as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is supplied.",
       "         = 'U':  Upper triangular part of A is supplied",
       "         = 'L':  Lower triangular part of A is supplied"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANSP is",
       "         set to zero."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "zlabrd"=>
  {"summary"=>
    ["ZLABRD reduces the first NB rows and columns of a complex general",
     "m by n matrix A to upper or lower real bidiagonal form by a unitary",
     "transformation Q**H * A * P, and returns the matrices X and Y which",
     "are needed to apply the transformation to the unreduced part of A.",
     "If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower",
     "bidiagonal form.",
     "This is an auxiliary routine called by ZGEBRD"],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of leading rows and columns of A to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the m by n general matrix to be reduced.",
       "         On exit, the first NB rows and columns of the matrix are",
       "         overwritten; the rest of the array is unchanged.",
       "         If m >= n, elements on and below the diagonal in the first NB",
       "           columns, with the array TAUQ, represent the unitary",
       "           matrix Q as a product of elementary reflectors; and",
       "           elements above the diagonal in the first NB rows, with the",
       "           array TAUP, represent the unitary matrix P as a product",
       "           of elementary reflectors.",
       "         If m < n, elements below the diagonal in the first NB",
       "           columns, with the array TAUQ, represent the unitary",
       "           matrix Q as a product of elementary reflectors, and",
       "           elements on and above the diagonal in the first NB rows,",
       "           with the array TAUP, represent the unitary matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (NB)",
       "         The diagonal elements of the first NB rows and columns of",
       "         the reduced matrix.  D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (NB)",
       "         The off-diagonal elements of the first NB rows and columns of",
       "         the reduced matrix."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is COMPLEX*16 array dimension (NB)",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is COMPLEX*16 array, dimension (NB)",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix P. See Further Details."],
     "X"=>
      ["[out]",
       "         X is COMPLEX*16 array, dimension (LDX,NB)",
       "         The m-by-nb matrix X required to update the unreduced part",
       "         of A."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X. LDX >= max(1,M)."],
     "Y"=>
      ["[out]",
       "         Y is COMPLEX*16 array, dimension (LDY,NB)",
       "         The n-by-nb matrix Y required to update the unreduced part",
       "         of A."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "         The leading dimension of the array Y. LDY >= max(1,N)."]}},
 "zhetrd_2stage"=>
  {"summary"=>
    ["ZHETRD_2STAGE reduces a complex Hermitian matrix A to real symmetric",
     "tridiagonal form T by a unitary similarity transformation:",
     "Q1**H Q2**H* A * Q2 * Q1 = T."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  No need for the Housholder representation, ",
       "                 in particular for the second stage (Band to",
       "                 tridiagonal) and thus LHOUS2 is of size max(1, 4*N);",
       "         = 'V':  the Householder representation is needed to ",
       "                 either generate Q1 Q2 or to apply Q1 Q2, ",
       "                 then LHOUS2 is to be queried and computed.",
       "                 (NOT AVAILABLE IN THIS RELEASE)."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the band superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         internal band-diagonal matrix AB, and the elements above ",
       "         the KD superdiagonal, with the array TAU, represent the unitary",
       "         matrix Q1 as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and band subdiagonal of A are over-",
       "         written by the corresponding elements of the internal band-diagonal",
       "         matrix AB, and the elements below the KD subdiagonal, with",
       "         the array TAU, represent the unitary matrix Q1 as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (N-KD)",
       "         The scalar factors of the elementary reflectors of ",
       "         the first stage (see Further Details)."],
     "HOUS2"=>
      ["[out]",
       "         HOUS2 is COMPLEX*16 array, dimension LHOUS2, that",
       "         store the Householder representation of the stage2",
       "         band to tridiagonal."],
     "LHOUS2"=>
      ["[in]",
       "         LHOUS2 is INTEGER",
       "         The dimension of the array HOUS2. LHOUS2 = MAX(1, dimension)",
       "         If LWORK = -1, or LHOUS2=-1,",
       "         then a query is assumed; the routine",
       "         only calculates the optimal size of the HOUS2 array, returns",
       "         this value as the first entry of the HOUS2 array, and no error",
       "         message related to LHOUS2 is issued by XERBLA.",
       "         LHOUS2 = MAX(1, dimension) where",
       "         dimension = 4*N if VECT='N'",
       "         not available now if VECT='H'"],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK = MAX(1, dimension)",
       "         If LWORK = -1, or LHOUS2=-1,",
       "         then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA.",
       "         LWORK = MAX(1, dimension) where",
       "         dimension   = max(stage1,stage2) + (KD+1)*N",
       "                     = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                       + max(2*KD*KD, KD*NTHREADS) ",
       "                       + (KD+1)*N ",
       "         where KD is the blocking size of the reduction,",
       "         FACTOPTNB is the blocking used by the QR or LQ",
       "         algorithm, usually FACTOPTNB=128 is a good choice",
       "         NTHREADS is the number of threads used when",
       "         openMP compilation is enabled, otherwise =1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zstedc"=>
  {"summary"=>
    ["ZSTEDC computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric tridiagonal matrix using the divide and conquer method.",
     "The eigenvectors of a full or band complex Hermitian matrix can also",
     "be found if ZHETRD or ZHPTRD or ZHBTRD has been used to reduce this",
     "matrix to tridiagonal form.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none.  See DLAED3 for details."],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'I':  Compute eigenvectors of tridiagonal matrix also.",
       "         = 'V':  Compute eigenvectors of original Hermitian matrix",
       "                 also.  On entry, Z contains the unitary matrix used",
       "                 to reduce the original matrix to tridiagonal form."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the diagonal elements of the tridiagonal matrix.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the subdiagonal elements of the tridiagonal matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ,N)",
       "         On entry, if COMPZ = 'V', then Z contains the unitary",
       "         matrix used in the reduction to tridiagonal form.",
       "         On exit, if INFO = 0, then if COMPZ = 'V', Z contains the",
       "         orthonormal eigenvectors of the original Hermitian matrix,",
       "         and if COMPZ = 'I', Z contains the orthonormal eigenvectors",
       "         of the symmetric tridiagonal matrix.",
       "         If  COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1.",
       "         If eigenvectors are desired, then LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If COMPZ = 'N' or 'I', or N <= 1, LWORK must be at least 1.",
       "         If COMPZ = 'V' and N > 1, LWORK must be at least N*N.",
       "         Note that for COMPZ = 'V', then if N is less than or",
       "         equal to the minimum divide size, usually 25, then LWORK need",
       "         only be 1.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array,",
       "                                        dimension (LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If COMPZ = 'N' or N <= 1, LRWORK must be at least 1.",
       "         If COMPZ = 'V' and N > 1, LRWORK must be at least",
       "                        1 + 3*N + 2*N*lg N + 4*N**2 ,",
       "                        where lg( N ) = smallest integer k such",
       "                        that 2**k >= N.",
       "         If COMPZ = 'I' and N > 1, LRWORK must be at least",
       "                        1 + 4*N + 2*N**2 .",
       "         Note that for COMPZ = 'I' or 'V', then if N is less than or",
       "         equal to the minimum divide size, usually 25, then LRWORK",
       "         need only be max(1,2*(N-1)).",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If COMPZ = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If COMPZ = 'V' or N > 1,  LIWORK must be at least",
       "                                   6 + 6*N + 5*N*lg N.",
       "         If COMPZ = 'I' or N > 1,  LIWORK must be at least",
       "                                   3 + 5*N .",
       "         Note that for COMPZ = 'I' or 'V', then if N is less than or",
       "         equal to the minimum divide size, usually 25, then LIWORK",
       "         need only be 1.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The algorithm failed to compute an eigenvalue while",
       "               working on the submatrix lying in rows and columns",
       "               INFO/(N+1) through mod(INFO,N+1)."]}},
 "cgbtrs"=>
  {"summary"=>
    ["CGBTRS solves a system of linear equations",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B",
     "with a general band matrix A using the LU factorization computed",
     "by CGBTRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations.",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by CGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= N, row i of the matrix was",
       "         interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zrot"=>
  {"summary"=>
    ["ZROT   applies a plane rotation, where the cos (C) is real and the",
     "sin (S) is complex, and the vectors CX and CY are complex."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements in the vectors CX and CY."],
     "CX"=>
      ["[in,out]",
       "         CX is COMPLEX*16 array, dimension (N)",
       "         On input, the vector X.",
       "         On output, CX is overwritten with C*X + S*Y."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of CY.  INCX <> 0."],
     "CY"=>
      ["[in,out]",
       "         CY is COMPLEX*16 array, dimension (N)",
       "         On input, the vector Y.",
       "         On output, CY is overwritten with -CONJG(S)*X + C*Y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between successive values of CY.  INCX <> 0."],
     "C"=>["[in]", "         C is DOUBLE PRECISION"],
     "S"=>
      ["[in]",
       "         S is COMPLEX*16",
       "         C and S define a rotation",
       "            [  C          S  ]",
       "            [ -conjg(S)   C  ]",
       "         where C*C + S*CONJG(S) = 1.0."]}},
 "dspgv"=>
  {"summary"=>
    ["DSPGV computes all the eigenvalues and, optionally, the eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be symmetric, stored in packed format,",
     "and B is also positive definite."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension",
       "                           (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T, in the same storage",
       "         format as B."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors.  The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  DPPTRF or DSPEV returned an error code:",
       "            <= N:  if INFO = i, DSPEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero.",
       "            > N:   if INFO = n + i, for 1 <= i <= n, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "ssytri_3x"=>
  {"summary"=>
    ["SSYTRI_3X computes the inverse of a real symmetric indefinite",
     "matrix A using the factorization computed by SSYTRF_RK or SSYTRF_BK:",
     "    A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by SYTRF_RK and SSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the symmetric inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF_RK or SSYTRF_BK."],
     "WORK"=>
      ["[out]", "         WORK is REAL array, dimension (N+NB+1,NB+3)."],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "ztgsy2"=>
  {"summary"=>
    ["ZTGSY2 solves the generalized Sylvester equation",
     "            A * R - L * B = scale * C               (1)",
     "            D * R - L * E = scale * F",
     "using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices,",
     "(A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M,",
     "N-by-N and M-by-N, respectively. A, B, D and E are upper triangular",
     "(i.e., (A,D) and (B,E) in generalized Schur form).",
     "The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output",
     "scaling factor chosen to avoid overflow.",
     "In matrix notation solving equation (1) corresponds to solve",
     "Zx = scale * b, where Z is defined as",
     "       Z = [ kron(In, A)  -kron(B**H, Im) ]             (2)",
     "           [ kron(In, D)  -kron(E**H, Im) ],",
     "Ik is the identity matrix of size k and X**H is the conjuguate transpose of X.",
     "kron(X, Y) is the Kronecker product between the matrices X and Y.",
     "If TRANS = 'C', y in the conjugate transposed system Z**H*y = scale*b",
     "is solved for, which is equivalent to solve for R and L in",
     "            A**H * R  + D**H * L   = scale * C           (3)",
     "            R  * B**H + L  * E**H  = scale * -F",
     "This case is used to compute an estimate of Dif[(A, D), (B, E)] =",
     "= sigma_min(Z) using reverse communicaton with ZLACON.",
     "ZTGSY2 also (IJOB >= 1) contributes to the computation in ZTGSYL",
     "of an upper bound on the separation between to matrix pairs. Then",
     "the input (A, D), (B, E) are sub-pencils of two matrix pairs in",
     "ZTGSYL."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N', solve the generalized Sylvester equation (1).",
       "         = 'T': solve the 'transposed' system (3)."],
     "IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies what kind of functionality to be performed.",
       "         =0: solve (1) only.",
       "         =1: A contribution from this subsystem to a Frobenius",
       "             norm-based estimate of the separation between two matrix",
       "             pairs is computed. (look ahead strategy is used).",
       "         =2: A contribution from this subsystem to a Frobenius",
       "             norm-based estimate of the separation between two matrix",
       "             pairs is computed. (DGECON on sub-systems is used.)",
       "         Not referenced if TRANS = 'T'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         On entry, M specifies the order of A and D, and the row",
       "         dimension of C, F, R and L."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         On entry, N specifies the order of B and E, and the column",
       "         dimension of C, F, R and L."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA, M)",
       "         On entry, A contains an upper triangular matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the matrix A. LDA >= max(1, M)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, B contains an upper triangular matrix."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the matrix B. LDB >= max(1, N)."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC, N)",
       "         On entry, C contains the right-hand-side of the first matrix",
       "         equation in (1).",
       "         On exit, if IJOB = 0, C has been overwritten by the solution",
       "         R."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the matrix C. LDC >= max(1, M)."],
     "D"=>
      ["[in]",
       "         D is COMPLEX*16 array, dimension (LDD, M)",
       "         On entry, D contains an upper triangular matrix."],
     "LDD"=>
      ["[in]",
       "         LDD is INTEGER",
       "         The leading dimension of the matrix D. LDD >= max(1, M)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (LDE, N)",
       "         On entry, E contains an upper triangular matrix."],
     "LDE"=>
      ["[in]",
       "         LDE is INTEGER",
       "         The leading dimension of the matrix E. LDE >= max(1, N)."],
     "F"=>
      ["[in,out]",
       "         F is COMPLEX*16 array, dimension (LDF, N)",
       "         On entry, F contains the right-hand-side of the second matrix",
       "         equation in (1).",
       "         On exit, if IJOB = 0, F has been overwritten by the solution",
       "         L."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the matrix F. LDF >= max(1, M)."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         On exit, 0 <= SCALE <= 1. If 0 < SCALE < 1, the solutions",
       "         R and L (C and F on entry) will hold the solutions to a",
       "         slightly perturbed system but the input matrices A, B, D and",
       "         E have not been changed. If SCALE = 0, R and L will hold the",
       "         solutions to the homogeneous system with C = F = 0.",
       "         Normally, SCALE = 1."],
     "RDSUM"=>
      ["[in,out]",
       "         RDSUM is DOUBLE PRECISION",
       "         On entry, the sum of squares of computed contributions to",
       "         the Dif-estimate under computation by ZTGSYL, where the",
       "         scaling factor RDSCAL (see below) has been factored out.",
       "         On exit, the corresponding sum of squares updated with the",
       "         contributions from the current sub-system.",
       "         If TRANS = 'T' RDSUM is not touched.",
       "         NOTE: RDSUM only makes sense when ZTGSY2 is called by",
       "         ZTGSYL."],
     "RDSCAL"=>
      ["[in,out]",
       "         RDSCAL is DOUBLE PRECISION",
       "         On entry, scaling factor used to prevent overflow in RDSUM.",
       "         On exit, RDSCAL is updated w.r.t. the current contributions",
       "         in RDSUM.",
       "         If TRANS = 'T', RDSCAL is not touched.",
       "         NOTE: RDSCAL only makes sense when ZTGSY2 is called by",
       "         ZTGSYL."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, if INFO is set to",
       "           =0: Successful exit",
       "           <0: If INFO = -i, input argument number i is illegal.",
       "           >0: The matrix pairs (A, D) and (B, E) have common or very",
       "               close eigenvalues."]}},
 "zlaqr4"=>
  {"summary"=>
    ["   ZLAQR4 implements one level of recursion for ZLAQR0.",
     "   It is a complete implementation of the small bulge multi-shift",
     "   QR algorithm.  It may be called by ZLAQR0 and, for large enough",
     "   deflation window size, it may be called by ZLAQR3.  This",
     "   subroutine is identical to ZLAQR0 except that it calls ZLAQR2",
     "   instead of ZLAQR3.",
     "   ZLAQR4 computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**H, where T is an upper triangular matrix (the",
     "   Schur form), and Z is the unitary matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input unitary",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the unitary matrix Q:  A = Q*H*Q**H = (QZ)*H*(QZ)**H."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N and, if ILO.GT.1,",
       "          H(ILO,ILO-1) is zero. ILO and IHI are normally set by a",
       "          previous call to ZGEBAL, and then passed to ZGEHRD when the",
       "          matrix output by ZGEBAL is reduced to Hessenberg form.",
       "          Otherwise, ILO and IHI should be set to 1 and N,",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX*16 array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and WANTT is .TRUE., then H",
       "          contains the upper triangular matrix T from the Schur",
       "          decomposition (the Schur form). If INFO = 0 and WANT is",
       "          .FALSE., then the contents of H are unspecified on exit.",
       "          (The output value of H when INFO.GT.0 is given under the",
       "          description of INFO below.)",
       "          This subroutine may explicitly set H(i,j) = 0 for i.GT.j and",
       "          j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX*16 array, dimension (N)",
       "          The computed eigenvalues of H(ILO:IHI,ILO:IHI) are stored",
       "          in W(ILO:IHI). If WANTT is .TRUE., then the eigenvalues are",
       "          stored in the same order as on the diagonal of the Schur",
       "          form returned in H, with W(i) = H(i,i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "          Specify the rows of Z to which transformations must be",
       "          applied if WANTZ is .TRUE..",
       "          1 .LE. ILOZ .LE. ILO; IHI .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ,IHI)",
       "          If WANTZ is .FALSE., then Z is not referenced.",
       "          If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is",
       "          replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the",
       "          orthogonal Schur factor of H(ILO:IHI,ILO:IHI).",
       "          (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if WANTZ is .TRUE.",
       "          then LDZ.GE.MAX(1,IHIZ).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension LWORK",
       "          On exit, if LWORK = -1, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient, but LWORK typically as large as 6*N may",
       "          be required for optimal performance.  A workspace query",
       "          to determine the optimal workspace size is recommended.",
       "          If LWORK = -1, then ZLAQR4 does a workspace query.",
       "          In this case, ZLAQR4 checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .GT. 0:  if INFO = i, ZLAQR4 failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and WANT is .FALSE., then on exit,",
       "               the remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is a unitary matrix.  The final",
       "               value of  H is upper Hessenberg and triangular in",
       "               rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                 (final value of Z(ILO:IHI,ILOZ:IHIZ)",
       "                  =  (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U",
       "               where U is the unitary matrix in (*) (regard-",
       "               less of the value of WANTT.)",
       "               If INFO .GT. 0 and WANTZ is .FALSE., then Z is not",
       "               accessed."]}},
 "classq"=>
  {"summary"=>
    ["CLASSQ returns the values scl and ssq such that",
     "   ( scl**2 )*ssq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq,",
     "where x( i ) = abs( X( 1 + ( i - 1 )*INCX ) ). The value of sumsq is",
     "assumed to be at least unity and the value of ssq will then satisfy",
     "   1.0 .le. ssq .le. ( sumsq + 2*n ).",
     "scale is assumed to be non-negative and scl returns the value",
     "   scl = max( scale, abs( real( x( i ) ) ), abs( aimag( x( i ) ) ) ),",
     "          i",
     "scale and sumsq must be supplied in SCALE and SUMSQ respectively.",
     "SCALE and SUMSQ are overwritten by scl and ssq respectively.",
     "The routine makes only one pass through the vector X."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements to be used from the vector X."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension (N)",
       "         The vector x as described above.",
       "            x( i )  = X( 1 + ( i - 1 )*INCX ), 1 <= i <= n."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of the vector X.",
       "         INCX > 0."],
     "SCALE"=>
      ["[in,out]",
       "         SCALE is REAL",
       "         On entry, the value  scale  in the equation above.",
       "         On exit, SCALE is overwritten with the value  scl ."],
     "SUMSQ"=>
      ["[in,out]",
       "         SUMSQ is REAL",
       "         On entry, the value  sumsq  in the equation above.",
       "         On exit, SUMSQ is overwritten with the value  ssq ."]}},
 "ssptrs"=>
  {"summary"=>
    ["SSPTRS solves a system of linear equations A*X = B with a real",
     "symmetric matrix A stored in packed format using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by SSPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by SSPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSPTRF."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "sgerq2"=>
  {"summary"=>
    ["SGERQ2 computes an RQ factorization of a real m by n matrix A:",
     "A = R * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, if m <= n, the upper triangle of the subarray",
       "         A(1:m,n-m+1:n) contains the m by m upper triangular matrix R;",
       "         if m >= n, the elements on and above the (m-n)-th subdiagonal",
       "         contain the m by n upper trapezoidal matrix R; the remaining",
       "         elements, with the array TAU, represent the orthogonal matrix",
       "         Q as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dgelqt"=>
  {"summary"=>
    ["DGELQT computes a blocked LQ factorization of a real M-by-N matrix A",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.  MIN(M,N) >= MB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the M-by-MIN(M,N) lower trapezoidal matrix L (L is",
       "         lower triangular if M <= N); the elements above the diagonal",
       "         are the rows of V."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,MIN(M,N))",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (MB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chegvx"=>
  {"summary"=>
    ["CHEGVX computes selected eigenvalues, and optionally, eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be Hermitian and B is also positive definite.",
     "Eigenvalues and eigenvectors can be selected by specifying either a",
     "range of values or a range of indices for the desired eigenvalues."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit,  the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the Hermitian matrix B.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of B contains the",
       "         upper triangular part of the matrix B.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of B contains",
       "         the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing C to tridiagonal form, where C is the symmetric",
       "         matrix of the standard symmetric problem to which the",
       "         generalized problem is transformed.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,2*N).",
       "         For optimal efficiency, LWORK >= (NB+1)*N,",
       "         where NB is the blocksize for CHETRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  CPOTRF or CHEEVX returned an error code:",
       "            <= N:  if INFO = i, CHEEVX failed to converge;",
       "                   i eigenvectors failed to converge.  Their indices",
       "                   are stored in array IFAIL.",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "sla_syrpvgrw"=>
  {"summary"=>
    ["SLA_SYRPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "INFO"=>
      ["[in]",
       "         INFO is INTEGER",
       "    The value of INFO returned from SSYTRF, .i.e., the pivot in",
       "    column INFO is exactly 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by SSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by SSYTRF."],
     "WORK"=>["[in]", "         WORK is REAL array, dimension (2*N)"]}},
 "cunbdb6"=>
  {"summary"=>[],
   "param"=>
    {"M1"=>
      ["[in]",
       "         M1 is INTEGER",
       "          The dimension of X1 and the number of rows in Q1. 0 <= M1."],
     "M2"=>
      ["[in]",
       "         M2 is INTEGER",
       "          The dimension of X2 and the number of rows in Q2. 0 <= M2."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The number of columns in Q1 and Q2. 0 <= N."],
     "X1"=>
      ["[in,out]",
       "         X1 is COMPLEX array, dimension (M1)",
       "          On entry, the top part of the vector to be orthogonalized.",
       "          On exit, the top part of the projected vector."],
     "INCX1"=>
      ["[in]",
       "         INCX1 is INTEGER",
       "          Increment for entries of X1."],
     "X2"=>
      ["[in,out]",
       "         X2 is COMPLEX array, dimension (M2)",
       "          On entry, the bottom part of the vector to be",
       "          orthogonalized. On exit, the bottom part of the projected",
       "          vector."],
     "INCX2"=>
      ["[in]",
       "         INCX2 is INTEGER",
       "          Increment for entries of X2."],
     "Q1"=>
      ["[in]",
       "         Q1 is COMPLEX array, dimension (LDQ1, N)",
       "          The top part of the orthonormal basis matrix."],
     "LDQ1"=>
      ["[in]",
       "         LDQ1 is INTEGER",
       "          The leading dimension of Q1. LDQ1 >= M1."],
     "Q2"=>
      ["[in]",
       "         Q2 is COMPLEX array, dimension (LDQ2, N)",
       "          The bottom part of the orthonormal basis matrix."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "          The leading dimension of Q2. LDQ2 >= M2."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ssyevr_2stage"=>
  {"summary"=>
    ["SSYEVR_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  Eigenvalues and eigenvectors can be",
     "selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues.",
     "SSYEVR_2STAGE first reduces the matrix A to tridiagonal form T with a call",
     "to SSYTRD.  Then, whenever possible, SSYEVR_2STAGE calls SSTEMR to compute",
     "the eigenspectrum using Relatively Robust Representations.  SSTEMR",
     "computes eigenvalues by the dqds algorithm, while orthogonal",
     "eigenvectors are computed from various \"good\" L D L^T representations",
     "(also known as Relatively Robust Representations). Gram-Schmidt",
     "orthogonalization is avoided as far as possible. More specifically,",
     "the various steps of the algorithm are as follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "The desired accuracy of the output can be specified by the input",
     "parameter ABSTOL.",
     "For more details, see SSTEMR's documentation and:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Note 1 : SSYEVR_2STAGE calls SSTEMR when the full spectrum is requested",
     "on machines which conform to the ieee-754 floating point standard.",
     "SSYEVR_2STAGE calls SSTEBZ and SSTEIN on non-ieee machines and",
     "when partial spectrum requests are made.",
     "Normal execution of SSTEMR may create NaNs and infinities and",
     "hence may abort due to a floating point exception in environments",
     "which do not handle NaNs and infinities in the ieee standard default",
     "manner."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found.",
       "         For RANGE = 'V' or 'I' and IU - IL < N - 1, SSTEBZ and",
       "         SSTEIN are called"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3.",
       "         If high relative accuracy is important, set ABSTOL to",
       "         SLAMCH( 'Safe minimum' ).  Doing so will guarantee that",
       "         eigenvalues are computed to high relative accuracy when",
       "         possible in future releases.  The current code does not",
       "         make any guarantees about high relative accuracy, but",
       "         future releases will. See J. Barlow and J. Demmel,",
       "         \"Computing Accurate Eigensystems of Scaled Diagonally",
       "         Dominant Matrices\", LAPACK Working Note #7, for a discussion",
       "         of which matrices define their eigenvalues to high relative",
       "         accuracy."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used.",
       "         Supplying N columns is always safe."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is an output of SSTEMR (tridiagonal",
       "         matrix). The support of the eigenvectors of A is typically ",
       "         1:N because of the orthogonal transformations applied by SORMTR.",
       "         Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1"],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, 26*N, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + 5*N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + 5*N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  Internal error"]}},
 "ctbtrs"=>
  {"summary"=>
    ["CTBTRS solves a triangular system of the form",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B,",
     "where A is a triangular band matrix of order N, and B is an",
     "N-by-NRHS matrix.  A check is made to verify that A is nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of AB.  The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element of A is zero,",
       "               indicating that the matrix is singular and the",
       "               solutions X have not been computed."]}},
 "zgbrfsx"=>
  {"summary"=>
    ["   ZGBRFSX improves the computed solution to a system of linear",
     "   equations and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED, R",
     "   and C below. In this case, the solution and error bounds returned",
     "   are for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "              diag(R).",
       "      = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "              by diag(C).",
       "      = 'B':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(R) * A * diag(C).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "    The original band matrix A, stored in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX*16 array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by DGBTRF.  U is stored as an upper triangular band",
       "    matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "    the multipliers used during the factorization are stored in",
       "    rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL*KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from DGETRF; for 1<=i<=N, row i of the",
       "    matrix was interchanged with row IPIV(i)."],
     "R"=>
      ["[in,out]",
       "         R is DOUBLE PRECISION array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'R' or 'B', A is",
       "    multiplied on the left by diag(R); if EQUED = 'N' or 'C', R",
       "    is not accessed.  R is an input argument if FACT = 'F';",
       "    otherwise, R is an output argument.  If FACT = 'F' and",
       "    EQUED = 'R' or 'B', each element of R must be positive.",
       "    If R is output, each element of R is a power of the radix.",
       "    If R is input, each element of R should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A.  If EQUED = 'C' or 'B', A is",
       "    multiplied on the right by diag(C); if EQUED = 'N' or 'R', C",
       "    is not accessed.  C is an input argument if FACT = 'F';",
       "    otherwise, C is an output argument.  If FACT = 'F' and",
       "    EQUED = 'C' or 'B', each element of C must be positive.",
       "    If C is output, each element of C is a power of the radix.",
       "    If C is input, each element of C should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by DGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is DOUBLE PRECISION array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0D+0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "dlagv2"=>
  {"summary"=>
    ["DLAGV2 computes the Generalized Schur factorization of a real 2-by-2",
     "matrix pencil (A,B) where B is upper triangular. This routine",
     "computes orthogonal (rotation) matrices given by CSL, SNL and CSR,",
     "SNR such that",
     "1) if the pencil (A,B) has two real eigenvalues (include 0/0 or 1/0",
     "   types), then",
     "   [ a11 a12 ] := [  CSL  SNL ] [ a11 a12 ] [  CSR -SNR ]",
     "   [  0  a22 ]    [ -SNL  CSL ] [ a21 a22 ] [  SNR  CSR ]",
     "   [ b11 b12 ] := [  CSL  SNL ] [ b11 b12 ] [  CSR -SNR ]",
     "   [  0  b22 ]    [ -SNL  CSL ] [  0  b22 ] [  SNR  CSR ],",
     "2) if the pencil (A,B) has a pair of complex conjugate eigenvalues,",
     "   then",
     "   [ a11 a12 ] := [  CSL  SNL ] [ a11 a12 ] [  CSR -SNR ]",
     "   [ a21 a22 ]    [ -SNL  CSL ] [ a21 a22 ] [  SNR  CSR ]",
     "   [ b11  0  ] := [  CSL  SNL ] [ b11 b12 ] [  CSR -SNR ]",
     "   [  0  b22 ]    [ -SNL  CSL ] [  0  b22 ] [  SNR  CSR ]",
     "   where b11 >= b22 > 0."],
   "param"=>
    {"A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, 2)",
       "         On entry, the 2 x 2 matrix A.",
       "         On exit, A is overwritten by the ``A-part'' of the",
       "         generalized Schur form."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         THe leading dimension of the array A.  LDA >= 2."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, 2)",
       "         On entry, the upper triangular 2 x 2 matrix B.",
       "         On exit, B is overwritten by the ``B-part'' of the",
       "         generalized Schur form."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         THe leading dimension of the array B.  LDB >= 2."],
     "ALPHAR"=>
      ["[out]", "         ALPHAR is DOUBLE PRECISION array, dimension (2)"],
     "ALPHAI"=>
      ["[out]", "         ALPHAI is DOUBLE PRECISION array, dimension (2)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (2)",
       "         (ALPHAR(k)+i*ALPHAI(k))/BETA(k) are the eigenvalues of the",
       "         pencil (A,B), k=1,2, i = sqrt(-1).  Note that BETA(k) may",
       "         be zero."],
     "CSL"=>
      ["[out]",
       "         CSL is DOUBLE PRECISION",
       "         The cosine of the left rotation matrix."],
     "SNL"=>
      ["[out]",
       "         SNL is DOUBLE PRECISION",
       "         The sine of the left rotation matrix."],
     "CSR"=>
      ["[out]",
       "         CSR is DOUBLE PRECISION",
       "         The cosine of the right rotation matrix."],
     "SNR"=>
      ["[out]",
       "         SNR is DOUBLE PRECISION",
       "         The sine of the right rotation matrix."]}},
 "csptrf"=>
  {"summary"=>
    ["CSPTRF computes the factorization of a complex symmetric matrix A",
     "stored in packed format using the Bunch-Kaufman diagonal pivoting",
     "method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L, stored as a packed triangular",
       "         matrix overwriting A (see below for further details)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "dgetrf2"=>
  {"summary"=>
    ["DGETRF2 computes an LU factorization of a general M-by-N matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the recursive version of the algorithm. It divides",
     "the matrix into four submatrices:",
     "       [  A11 | A12  ]  where A11 is n1 by n1 and A22 is n2 by n2",
     "   A = [ -----|----- ]  with n1 = min(m,n)/2",
     "       [  A21 | A22  ]       n2 = n-n1",
     "                                      [ A11 ]",
     "The subroutine calls itself to factor [ --- ],",
     "                                      [ A12 ]",
     "                [ A12 ]",
     "do the swaps on [ --- ], solve A12, update A22,",
     "                [ A22 ]",
     "then calls itself to factor A22 and do the swaps on A21."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "sptcon"=>
  {"summary"=>
    ["SPTCON computes the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric positive definite tridiagonal matrix",
     "using the factorization A = L*D*L**T or A = U**T*D*U computed by",
     "SPTTRF.",
     "Norm(inv(A)) is computed by a direct method, and the reciprocal of",
     "the condition number is computed as",
     "             RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         factorization of A, as computed by SPTTRF."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the unit bidiagonal factor",
       "         U or L from the factorization of A,  as computed by SPTTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is the",
       "         1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgbsvx"=>
  {"summary"=>
    ["SGBSVX uses the LU factorization to compute the solution to a real",
     "system of linear equations A * X = B, A**T * X = B, or A**H * X = B,",
     "where A is a band matrix of order N with KL subdiagonals and KU",
     "superdiagonals, and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "dsygv_2stage"=>
  {"summary"=>
    ["DSYGV_2STAGE computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be symmetric and B is also",
     "positive definite.",
     "This routine use the 2stage technique for the reduction to tridiagonal",
     "which showed higher performance on recent architecture and for large"],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the symmetric positive definite matrix B.",
       "         If UPLO = 'U', the leading N-by-N upper triangular part of B",
       "         contains the upper triangular part of the matrix B.",
       "         If UPLO = 'L', the leading N-by-N lower triangular part of B",
       "         contains the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + 2*N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + 2*N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  DPOTRF or DSYEV returned an error code:",
       "            <= N:  if INFO = i, DSYEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "ssptrd"=>
  {"summary"=>
    ["SSPTRD reduces a real symmetric matrix A stored in packed form to",
     "symmetric tridiagonal form T by an orthogonal similarity",
     "transformation: Q**T * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the orthogonal",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the orthogonal matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dorm2r"=>
  {"summary"=>
    ["DORM2R overwrites the general real m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**T* C  if SIDE = 'L' and TRANS = 'T', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**T if SIDE = 'R' and TRANS = 'T',",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by DGEQRF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left",
       "         = 'R': apply Q or Q**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'T': apply Q**T (Transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGEQRF in the first k columns of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGEQRF."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dsyconv"=>
  {"summary"=>
    ["DSYCONV convert A given by TRF into L and D and vice-versa.",
     "Get Non-diag elements of D (returned in workspace) and",
     "apply or reverse permutation done in TRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by DSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         E stores the supdiagonal/subdiagonal of the symmetric 1-by-1",
       "         or 2-by-2 block diagonal matrix D in LDLT."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhetri_3"=>
  {"summary"=>
    ["ZHETRI_3 computes the inverse of a complex Hermitian indefinite",
     "matrix A using the factorization computed by ZHETRF_RK or ZHETRF_BK:",
     "    A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "ZHETRI_3 sets the leading dimension of the workspace  before calling",
     "ZHETRI_3X that actually computes the inverse.  This is the blocked",
     "version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by ZHETRF_RK and ZHETRF_BK:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the Hermitian inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHETRF_RK or ZHETRF_BK."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (N+NB+1)*(NB+3).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK. LWORK >= (N+NB+1)*(NB+3).",
       "         If LDWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the optimal",
       "         size of the WORK array, returns this value as the first",
       "         entry of the WORK array, and no error message related to",
       "         LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "ztrsen"=>
  {"summary"=>
    ["ZTRSEN reorders the Schur factorization of a complex matrix",
     "A = Q*T*Q**H, so that a selected cluster of eigenvalues appears in",
     "the leading positions on the diagonal of the upper triangular matrix",
     "T, and the leading columns of Q form an orthonormal basis of the",
     "corresponding right invariant subspace.",
     "Optionally the routine computes the reciprocal condition numbers of",
     "the cluster of eigenvalues and/or the invariant subspace."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for the",
       "         cluster of eigenvalues (S) or the invariant subspace (SEP):",
       "         = 'N': none;",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for invariant subspace only (SEP);",
       "         = 'B': for both eigenvalues and invariant subspace (S and",
       "                SEP)."],
     "COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'V': update the matrix Q of Schur vectors;",
       "         = 'N': do not update Q."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         SELECT specifies the eigenvalues in the selected cluster. To",
       "         select the j-th eigenvalue, SELECT(j) must be set to .TRUE.."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in,out]",
       "         T is COMPLEX*16 array, dimension (LDT,N)",
       "         On entry, the upper triangular matrix T.",
       "         On exit, T is overwritten by the reordered matrix T, with the",
       "         selected eigenvalues as the leading diagonal elements."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,N)",
       "         On entry, if COMPQ = 'V', the matrix Q of Schur vectors.",
       "         On exit, if COMPQ = 'V', Q has been postmultiplied by the",
       "         unitary transformation matrix which reorders T; the leading M",
       "         columns of Q form an orthonormal basis for the specified",
       "         invariant subspace.",
       "         If COMPQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= 1; and if COMPQ = 'V', LDQ >= N."],
     "W"=>
      ["[out]",
       "         W is COMPLEX*16 array, dimension (N)",
       "         The reordered eigenvalues of T, in the same order as they",
       "         appear on the diagonal of T."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The dimension of the specified invariant subspace.",
       "         0 <= M <= N."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION",
       "         If JOB = 'E' or 'B', S is a lower bound on the reciprocal",
       "         condition number for the selected cluster of eigenvalues.",
       "         S cannot underestimate the true reciprocal condition number",
       "         by more than a factor of sqrt(N). If M = 0 or N, S = 1.",
       "         If JOB = 'N' or 'V', S is not referenced."],
     "SEP"=>
      ["[out]",
       "         SEP is DOUBLE PRECISION",
       "         If JOB = 'V' or 'B', SEP is the estimated reciprocal",
       "         condition number of the specified invariant subspace. If",
       "         M = 0 or N, SEP = norm(T).",
       "         If JOB = 'N' or 'E', SEP is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If JOB = 'N', LWORK >= 1;",
       "         if JOB = 'E', LWORK = max(1,M*(N-M));",
       "         if JOB = 'V' or 'B', LWORK >= max(1,2*M*(N-M)).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgels"=>
  {"summary"=>
    ["ZGELS solves overdetermined or underdetermined complex linear systems",
     "involving an M-by-N matrix A, or its conjugate-transpose, using a QR",
     "or LQ factorization of A.  It is assumed that A has full rank.",
     "The following options are provided:",
     "1. If TRANS = 'N' and m >= n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A*X ||.",
     "2. If TRANS = 'N' and m < n:  find the minimum norm solution of",
     "   an underdetermined system A * X = B.",
     "3. If TRANS = 'C' and m >= n:  find the minimum norm solution of",
     "   an underdetermined system A**H * X = B.",
     "4. If TRANS = 'C' and m < n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A**H * X ||.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': the linear system involves A;",
       "         = 'C': the linear system involves A**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of the matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "           if M >= N, A is overwritten by details of its QR",
       "                      factorization as returned by ZGEQRF;",
       "           if M <  N, A is overwritten by details of its LQ",
       "                      factorization as returned by ZGELQF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the matrix B of right hand side vectors, stored",
       "         columnwise; B is M-by-NRHS if TRANS = 'N', or N-by-NRHS",
       "         if TRANS = 'C'.",
       "         On exit, if INFO = 0, B is overwritten by the solution",
       "         vectors, stored columnwise:",
       "         if TRANS = 'N' and m >= n, rows 1 to n of B contain the least",
       "         squares solution vectors; the residual sum of squares for the",
       "         solution in each column is given by the sum of squares of the",
       "         modulus of elements N+1 to M in that column;",
       "         if TRANS = 'N' and m < n, rows 1 to N of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'C' and m >= n, rows 1 to M of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'C' and m < n, rows 1 to M of B contain the",
       "         least squares solution vectors; the residual sum of squares",
       "         for the solution in each column is given by the sum of",
       "         squares of the modulus of elements M+1 to N in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= MAX(1,M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= max( 1, MN + max( MN, NRHS ) ).",
       "         For optimal performance,",
       "         LWORK >= max( 1, MN + max( MN, NRHS )*NB ).",
       "         where MN = min(M,N) and NB is the optimum block size.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO =  i, the i-th diagonal element of the",
       "               triangular factor of A is zero, so that A does not have",
       "               full rank; the least squares solution could not be",
       "               computed."]}},
 "slarrj"=>
  {"summary"=>
    ["Given the initial eigenvalue approximations of T, SLARRJ",
     "does  bisection to refine the eigenvalues of T,",
     "W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial",
     "guesses for these eigenvalues are input in W, the corresponding estimate",
     "of the error in these guesses in WERR. During bisection, intervals",
     "[left, right] are maintained by storing their mid-points and",
     "semi-widths in the arrays W and WERR respectively."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The N diagonal elements of T."],
     "E2"=>
      ["[in]",
       "         E2 is REAL array, dimension (N-1)",
       "         The Squares of the (N-1) subdiagonal elements of T."],
     "IFIRST"=>
      ["[in]",
       "         IFIRST is INTEGER",
       "         The index of the first eigenvalue to be computed."],
     "ILAST"=>
      ["[in]",
       "         ILAST is INTEGER",
       "         The index of the last eigenvalue to be computed."],
     "RTOL"=>
      ["[in]",
       "         RTOL is REAL",
       "         Tolerance for the convergence of the bisection intervals.",
       "         An interval [LEFT,RIGHT] has converged if",
       "         RIGHT-LEFT.LT.RTOL*MAX(|LEFT|,|RIGHT|)."],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         Offset for the arrays W and WERR, i.e., the IFIRST-OFFSET",
       "         through ILAST-OFFSET elements of these arrays are to be used."],
     "W"=>
      ["[in,out]",
       "         W is REAL array, dimension (N)",
       "         On input, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ) are",
       "         estimates of the eigenvalues of L D L^T indexed IFIRST through",
       "         ILAST.",
       "         On output, these estimates are refined."],
     "WERR"=>
      ["[in,out]",
       "         WERR is REAL array, dimension (N)",
       "         On input, WERR( IFIRST-OFFSET ) through WERR( ILAST-OFFSET ) are",
       "         the errors in the estimates of the corresponding elements in W.",
       "         On output, these errors are refined."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (2*N)",
       "         Workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (2*N)",
       "         Workspace."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "         The minimum pivot in the Sturm sequence for T."],
     "SPDIAM"=>
      ["[in]",
       "         SPDIAM is REAL",
       "         The spectral diameter of T."],
     "INFO"=>["[out]", "         INFO is INTEGER", "         Error flag."]}},
 "cgghrd"=>
  {"summary"=>
    ["CGGHRD reduces a pair of complex matrices (A,B) to generalized upper",
     "Hessenberg form using unitary transformations, where A is a",
     "general matrix and B is upper triangular.  The form of the generalized",
     "eigenvalue problem is",
     "   A*x = lambda*B*x,",
     "and B is typically made upper triangular by computing its QR",
     "factorization and moving the unitary matrix Q to the left side",
     "of the equation.",
     "This subroutine simultaneously reduces A to a Hessenberg matrix H:",
     "   Q**H*A*Z = H",
     "and transforms B to another upper triangular matrix T:",
     "   Q**H*B*Z = T",
     "in order to reduce the problem to its standard form",
     "   H*y = lambda*T*y",
     "where y = Z**H*x.",
     "The unitary matrices Q and Z are determined as products of Givens",
     "rotations.  They may either be formed explicitly, or they may be",
     "postmultiplied into input matrices Q1 and Z1, so that",
     "     Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H",
     "     Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H",
     "If Q1 is the unitary matrix from the QR factorization of B in the",
     "original equation A*x = lambda*B*x, then CGGHRD reduces the original",
     "problem to generalized Hessenberg form."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': do not compute Q;",
       "         = 'I': Q is initialized to the unit matrix, and the",
       "                unitary matrix Q is returned;",
       "         = 'V': Q must contain a unitary matrix Q1 on entry,",
       "                and the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': do not compute Z;",
       "         = 'I': Z is initialized to the unit matrix, and the",
       "                unitary matrix Z is returned;",
       "         = 'V': Z must contain a unitary matrix Z1 on entry,",
       "                and the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of A which are to be",
       "         reduced.  It is assumed that A is already upper triangular",
       "         in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are",
       "         normally set by a previous call to CGGBAL; otherwise they",
       "         should be set to 1 and N respectively.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         rest is set to zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the N-by-N upper triangular matrix B.",
       "         On exit, the upper triangular matrix T = Q**H B Z.  The",
       "         elements below the diagonal are set to zero."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the unitary matrix Q1, typically",
       "         from the QR factorization of B.",
       "         On exit, if COMPQ='I', the unitary matrix Q, and if",
       "         COMPQ = 'V', the product Q1*Q.",
       "         Not referenced if COMPQ='N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the unitary matrix Z1.",
       "         On exit, if COMPZ='I', the unitary matrix Z, and if",
       "         COMPZ = 'V', the product Z1*Z.",
       "         Not referenced if COMPZ='N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.",
       "         LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ztplqt"=>
  {"summary"=>
    ["DTPLQT computes a blocked LQ factorization of a complex",
     "\"triangular-pentagonal\" matrix C, which is composed of a",
     "triangular block A and pentagonal block B, using the compact",
     "WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B, and the order of the",
       "         triangular matrix A.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the lower trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.  M >= MB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the lower triangular N-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the lower triangular matrix L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first N-L columns",
       "         are rectangular, and the last L columns are lower trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,N)",
       "         The lower triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (MB*M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ssytrf_rk"=>
  {"summary"=>
    ["SSYTRF_RK computes the factorization of a real symmetric matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension ( MAX(1,LWORK) ).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned",
       "         by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array, returns this value as the first entry of the WORK",
       "         array, and no error message related to LWORK is issued",
       "         by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "ssytf2"=>
  {"summary"=>
    ["SSYTF2 computes the factorization of a real symmetric matrix A using",
     "the Bunch-Kaufman diagonal pivoting method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**T is the transpose of U, and D is symmetric and",
     "block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "ctrevc3"=>
  {"summary"=>
    ["CTREVC3 computes some or all of the right and/or left eigenvectors of",
     "a complex upper triangular matrix T.",
     "Matrices of this type are produced by the Schur factorization of",
     "a complex general matrix:  A = Q*T*Q**H, as computed by CHSEQR.",
     "The right eigenvector x and the left eigenvector y of T corresponding",
     "to an eigenvalue w are defined by:",
     "             T*x = w*x,     (y**H)*T = w*(y**H)",
     "where y**H denotes the conjugate transpose of the vector y.",
     "The eigenvalues are not input to this routine, but are read directly",
     "from the diagonal of T.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an",
     "input matrix. If Q is the unitary factor that reduces a matrix A to",
     "Schur form T, then Q*X and Q*Y are the matrices of right and left",
     "eigenvectors of A.",
     "This uses a Level 3 BLAS version of the back transformation."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  compute right eigenvectors only;",
       "         = 'L':  compute left eigenvectors only;",
       "         = 'B':  compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A':  compute all right and/or left eigenvectors;",
       "         = 'B':  compute all right and/or left eigenvectors,",
       "                 backtransformed using the matrices supplied in",
       "                 VR and/or VL;",
       "         = 'S':  compute selected right and/or left eigenvectors,",
       "                 as indicated by the logical array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenvectors to be",
       "         computed.",
       "         The eigenvector corresponding to the j-th eigenvalue is",
       "         computed if SELECT(j) = .TRUE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in,out]",
       "         T is COMPLEX array, dimension (LDT,N)",
       "         The upper triangular matrix T.  T is modified, but restored",
       "         on exit."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is COMPLEX array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Q of",
       "         Schur vectors returned by CHSEQR).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VL, in the same order as their",
       "                          eigenvalues.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= 1, and if SIDE = 'L' or 'B', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is COMPLEX array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Q of",
       "         Schur vectors returned by CHSEQR).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*X;",
       "         if HOWMNY = 'S', the right eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VR, in the same order as their",
       "                          eigenvalues.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= 1, and if SIDE = 'R' or 'B', LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.",
       "         If HOWMNY = 'A' or 'B', M is set to N.",
       "         Each selected eigenvector occupies one column."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of array WORK. LWORK >= max(1,2*N).",
       "         For optimum performance, LWORK >= N + 2*N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (LRWORK)"],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK. LRWORK >= max(1,N).",
       "         If LRWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the RWORK array, returns",
       "         this value as the first entry of the RWORK array, and no error",
       "         message related to LRWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgghrd"=>
  {"summary"=>
    ["ZGGHRD reduces a pair of complex matrices (A,B) to generalized upper",
     "Hessenberg form using unitary transformations, where A is a",
     "general matrix and B is upper triangular.  The form of the",
     "generalized eigenvalue problem is",
     "   A*x = lambda*B*x,",
     "and B is typically made upper triangular by computing its QR",
     "factorization and moving the unitary matrix Q to the left side",
     "of the equation.",
     "This subroutine simultaneously reduces A to a Hessenberg matrix H:",
     "   Q**H*A*Z = H",
     "and transforms B to another upper triangular matrix T:",
     "   Q**H*B*Z = T",
     "in order to reduce the problem to its standard form",
     "   H*y = lambda*T*y",
     "where y = Z**H*x.",
     "The unitary matrices Q and Z are determined as products of Givens",
     "rotations.  They may either be formed explicitly, or they may be",
     "postmultiplied into input matrices Q1 and Z1, so that",
     "     Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H",
     "     Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H",
     "If Q1 is the unitary matrix from the QR factorization of B in the",
     "original equation A*x = lambda*B*x, then ZGGHRD reduces the original",
     "problem to generalized Hessenberg form."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': do not compute Q;",
       "         = 'I': Q is initialized to the unit matrix, and the",
       "                unitary matrix Q is returned;",
       "         = 'V': Q must contain a unitary matrix Q1 on entry,",
       "                and the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': do not compute Z;",
       "         = 'I': Z is initialized to the unit matrix, and the",
       "                unitary matrix Z is returned;",
       "         = 'V': Z must contain a unitary matrix Z1 on entry,",
       "                and the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of A which are to be",
       "         reduced.  It is assumed that A is already upper triangular",
       "         in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are",
       "         normally set by a previous call to ZGGBAL; otherwise they",
       "         should be set to 1 and N respectively.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         rest is set to zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the N-by-N upper triangular matrix B.",
       "         On exit, the upper triangular matrix T = Q**H B Z.  The",
       "         elements below the diagonal are set to zero."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the unitary matrix Q1, typically",
       "         from the QR factorization of B.",
       "         On exit, if COMPQ='I', the unitary matrix Q, and if",
       "         COMPQ = 'V', the product Q1*Q.",
       "         Not referenced if COMPQ='N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the unitary matrix Z1.",
       "         On exit, if COMPZ='I', the unitary matrix Z, and if",
       "         COMPZ = 'V', the product Z1*Z.",
       "         Not referenced if COMPZ='N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.",
       "         LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zporfsx"=>
  {"summary"=>
    ["   ZPORFSX improves the computed solution to a system of linear",
     "   equations when the coefficient matrix is symmetric positive",
     "   definite, and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED and S",
     "   below. In this case, the solution and error bounds returned are",
     "   for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'Y':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(S) * A * diag(S).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "    upper triangular part of A contains the upper triangular part",
       "    of the matrix A, and the strictly lower triangular part of A",
       "    is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "    triangular part of A contains the lower triangular part of",
       "    the matrix A, and the strictly upper triangular part of A is",
       "    not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by DPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "S"=>
      ["[in,out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'Y', A is multiplied on",
       "    the left and right by diag(S).  S is an input argument if FACT =",
       "    'F'; otherwise, S is an output argument.  If FACT = 'F' and EQUED",
       "    = 'Y', each element of S must be positive.  If S is output, each",
       "    element of S is a power of the radix. If S is input, each element",
       "    of S should be a power of the radix to ensure a reliable solution",
       "    and error estimates. Scaling by powers of the radix does not cause",
       "    rounding errors unless the result underflows or overflows.",
       "    Rounding errors during scaling lead to refining with a matrix that",
       "    is not equivalent to the input matrix, producing error estimates",
       "    that may not be reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by DGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is DOUBLE PRECISION array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0D+0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "dsgesv"=>
  {"summary"=>
    ["DSGESV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N matrix and X and B are N-by-NRHS matrices.",
     "DSGESV first attempts to factorize the matrix in SINGLE PRECISION",
     "and use this factorization within an iterative refinement procedure",
     "to produce a solution with DOUBLE PRECISION normwise backward error",
     "quality (see below). If the approach fails the method switches to a",
     "DOUBLE PRECISION factorization and solve.",
     "The iterative refinement is not going to be a winning strategy if",
     "the ratio SINGLE PRECISION performance over DOUBLE PRECISION",
     "performance is too small. A reasonable strategy should take the",
     "number of right-hand sides and the size of the matrix into account.",
     "This might be done with a call to ILAENV in the future. Up to now, we",
     "always try iterative refinement.",
     "The iterative refinement process is stopped if",
     "    ITER > ITERMAX",
     "or for all the RHS we have:",
     "    RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX",
     "where",
     "    o ITER is the number of the current iteration in the iterative",
     "      refinement process",
     "    o RNRM is the infinity-norm of the residual",
     "    o XNRM is the infinity-norm of the solution",
     "    o ANRM is the infinity-operator-norm of the matrix A",
     "    o EPS is the machine epsilon returned by DLAMCH('Epsilon')",
     "The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00",
     "respectively."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array,",
       "         dimension (LDA,N)",
       "         On entry, the N-by-N coefficient matrix A.",
       "         On exit, if iterative refinement has been successfully used",
       "         (INFO.EQ.0 and ITER.GE.0, see description below), then A is",
       "         unchanged, if double precision factorization has been used",
       "         (INFO.EQ.0 and ITER.LT.0, see description below), then the",
       "         array A contains the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices that define the permutation matrix P;",
       "         row i of the matrix was interchanged with row IPIV(i).",
       "         Corresponds either to the single precision factorization",
       "         (if INFO.EQ.0 and ITER.GE.0) or the double precision",
       "         factorization (if INFO.EQ.0 and ITER.LT.0)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The N-by-NRHS right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         If INFO = 0, the N-by-NRHS solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (N,NRHS)",
       "         This array is used to hold the residual vectors."],
     "SWORK"=>
      ["[out]",
       "         SWORK is REAL array, dimension (N*(N+NRHS))",
       "         This array is used to use the single precision matrix and the",
       "         right-hand sides or solutions in single precision."],
     "ITER"=>
      ["[out]",
       "         ITER is INTEGER",
       "         < 0: iterative refinement has failed, double precision",
       "              factorization has been performed",
       "              -1 : the routine fell back to full precision for",
       "                   implementation- or machine-specific reasons",
       "              -2 : narrowing the precision induced an overflow,",
       "                   the routine fell back to full precision",
       "              -3 : failure of SGETRF",
       "              -31: stop the iterative refinement after the 30th",
       "                   iterations",
       "         > 0: iterative refinement has been successfully used.",
       "              Returns the number of iterations"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) computed in DOUBLE PRECISION is",
       "               exactly zero.  The factorization has been completed,",
       "               but the factor U is exactly singular, so the solution",
       "               could not be computed."]}},
 "dstein"=>
  {"summary"=>
    ["DSTEIN computes the eigenvectors of a real symmetric tridiagonal",
     "matrix T corresponding to specified eigenvalues, using inverse",
     "iteration.",
     "The maximum number of iterations allowed for each eigenvector is",
     "specified by an internal parameter MAXITS (currently set to 5)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the tridiagonal matrix",
       "         T, in elements 1 to N-1."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of eigenvectors to be found.  0 <= M <= N."],
     "W"=>
      ["[in]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements of W contain the eigenvalues for",
       "         which eigenvectors are to be computed.  The eigenvalues",
       "         should be grouped by split-off block and ordered from",
       "         smallest to largest within the block.  ( The output array",
       "         W from DSTEBZ with ORDER = 'B' is expected here. )"],
     "IBLOCK"=>
      ["[in]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         The submatrix indices associated with the corresponding",
       "         eigenvalues in W; IBLOCK(i)=1 if eigenvalue W(i) belongs to",
       "         the first submatrix from the top, =2 if W(i) belongs to",
       "         the second submatrix, etc.  ( The output array IBLOCK",
       "         from DSTEBZ is expected here. )"],
     "ISPLIT"=>
      ["[in]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into submatrices.",
       "         The first submatrix consists of rows/columns 1 to",
       "         ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1",
       "         through ISPLIT( 2 ), etc.",
       "         ( The output array ISPLIT from DSTEBZ is expected here. )"],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, M)",
       "         The computed eigenvectors.  The eigenvector associated",
       "         with the eigenvalue W(i) is stored in the i-th column of",
       "         Z.  Any vector which fails to converge is set to its current",
       "         iterate after MAXITS iterations."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (5*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (M)",
       "         On normal exit, all elements of IFAIL are zero.",
       "         If one or more eigenvectors fail to converge after",
       "         MAXITS iterations, then their indices are stored in",
       "         array IFAIL."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit.",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, then i eigenvectors failed to converge",
       "              in MAXITS iterations.  Their indices are stored in",
       "              array IFAIL."]}},
 "chbgst"=>
  {"summary"=>
    ["CHBGST reduces a complex Hermitian-definite banded generalized",
     "eigenproblem  A*x = lambda*B*x  to standard form  C*y = lambda*y,",
     "such that C has the same bandwidth as A.",
     "B must have been previously factorized as S**H*S by CPBSTF, using a",
     "split Cholesky factorization. A is overwritten by C = X**H*A*X, where",
     "X = S**(-1)*Q and Q is a unitary matrix chosen to preserve the",
     "bandwidth of A."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  do not form the transformation matrix X;",
       "         = 'V':  form X."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the transformed matrix X**H*A*X, stored in the same",
       "         format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in]",
       "         BB is COMPLEX array, dimension (LDBB,N)",
       "         The banded factor S from the split Cholesky factorization of",
       "         B, as returned by CPBSTF, stored in the first kb+1 rows of",
       "         the array."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "X"=>
      ["[out]",
       "         X is COMPLEX array, dimension (LDX,N)",
       "         If VECT = 'V', the n-by-n matrix X.",
       "         If VECT = 'N', the array X is not referenced."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.",
       "         LDX >= max(1,N) if VECT = 'V'; LDX >= 1 otherwise."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zlacp2"=>
  {"summary"=>
    ["ZLACP2 copies all or part of a real two-dimensional matrix A to a",
     "complex matrix B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the part of the matrix A to be copied to B.",
       "         = 'U':      Upper triangular part",
       "         = 'L':      Lower triangular part",
       "         Otherwise:  All of the matrix A"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The m by n matrix A.  If UPLO = 'U', only the upper trapezium",
       "         is accessed; if UPLO = 'L', only the lower trapezium is",
       "         accessed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On exit, B = A in the locations specified by UPLO."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."]}},
 "zheev"=>
  {"summary"=>
    ["ZHEEV computes all eigenvalues and, optionally, eigenvectors of a",
     "complex Hermitian matrix A."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,2*N-1).",
       "         For optimal efficiency, LWORK >= (NB+1)*N,",
       "         where NB is the blocksize for ZHETRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "slabrd"=>
  {"summary"=>
    ["SLABRD reduces the first NB rows and columns of a real general",
     "m by n matrix A to upper or lower bidiagonal form by an orthogonal",
     "transformation Q**T * A * P, and returns the matrices X and Y which",
     "are needed to apply the transformation to the unreduced part of A.",
     "If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower",
     "bidiagonal form.",
     "This is an auxiliary routine called by SGEBRD"],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of leading rows and columns of A to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the m by n general matrix to be reduced.",
       "         On exit, the first NB rows and columns of the matrix are",
       "         overwritten; the rest of the array is unchanged.",
       "         If m >= n, elements on and below the diagonal in the first NB",
       "           columns, with the array TAUQ, represent the orthogonal",
       "           matrix Q as a product of elementary reflectors; and",
       "           elements above the diagonal in the first NB rows, with the",
       "           array TAUP, represent the orthogonal matrix P as a product",
       "           of elementary reflectors.",
       "         If m < n, elements below the diagonal in the first NB",
       "           columns, with the array TAUQ, represent the orthogonal",
       "           matrix Q as a product of elementary reflectors, and",
       "           elements on and above the diagonal in the first NB rows,",
       "           with the array TAUP, represent the orthogonal matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (NB)",
       "         The diagonal elements of the first NB rows and columns of",
       "         the reduced matrix.  D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (NB)",
       "         The off-diagonal elements of the first NB rows and columns of",
       "         the reduced matrix."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is REAL array dimension (NB)",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is REAL array, dimension (NB)",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix P. See Further Details."],
     "X"=>
      ["[out]",
       "         X is REAL array, dimension (LDX,NB)",
       "         The m-by-nb matrix X required to update the unreduced part",
       "         of A."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X. LDX >= max(1,M)."],
     "Y"=>
      ["[out]",
       "         Y is REAL array, dimension (LDY,NB)",
       "         The n-by-nb matrix Y required to update the unreduced part",
       "         of A."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "         The leading dimension of the array Y. LDY >= max(1,N)."]}},
 "ssbevd_2stage"=>
  {"summary"=>
    ["SSBEVD_2STAGE computes all the eigenvalues and, optionally, eigenvectors of",
     "a real symmetric band matrix A using the 2stage technique for",
     "the reduction to tridiagonal. If eigenvectors are desired, it uses",
     "a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension LWORK",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS + N",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 2, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "cla_gbrpvgrw"=>
  {"summary"=>
    ["CLA_GBRPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A.  NCOLS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "    On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by CGBTRF.  U is stored as an upper triangular",
       "    band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1,",
       "    and the multipliers used during the factorization are stored",
       "    in rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1."]}},
 "zsytrf_rk"=>
  {"summary"=>
    ["ZSYTRF_RK computes the factorization of a complex symmetric matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension ( MAX(1,LWORK) ).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned",
       "         by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array, returns this value as the first entry of the WORK",
       "         array, and no error message related to LWORK is issued",
       "         by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "zlanhs"=>
  {"summary"=>
    ["ZLANHS  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "Hessenberg matrix A.",
     "   ZLANHS = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANHS as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANHS is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The n by n upper Hessenberg matrix A; the part of A below the",
       "         first sub-diagonal is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "cgesdd"=>
  {"summary"=>
    ["CGESDD computes the singular value decomposition (SVD) of a complex",
     "M-by-N matrix A, optionally computing the left and/or right singular",
     "vectors, by using divide-and-conquer method. The SVD is written",
     "     A = U * SIGMA * conjugate-transpose(V)",
     "where SIGMA is an M-by-N matrix which is zero except for its",
     "min(m,n) diagonal elements, U is an M-by-M unitary matrix, and",
     "V is an N-by-N unitary matrix.  The diagonal elements of SIGMA",
     "are the singular values of A; they are real and non-negative, and",
     "are returned in descending order.  The first min(m,n) columns of",
     "U and V are the left and right singular vectors of A.",
     "Note that the routine returns VT = V**H, not V.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'A':  all M columns of U and all N rows of V**H are",
       "                 returned in the arrays U and VT;",
       "         = 'S':  the first min(M,N) columns of U and the first",
       "                 min(M,N) rows of V**H are returned in the arrays U",
       "                 and VT;",
       "         = 'O':  If M >= N, the first N columns of U are overwritten",
       "                 in the array A and all rows of V**H are returned in",
       "                 the array VT;",
       "                 otherwise, all columns of U are returned in the",
       "                 array U and the first M rows of V**H are overwritten",
       "                 in the array A;",
       "         = 'N':  no columns of U or rows of V**H are computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if JOBZ = 'O',  A is overwritten with the first N columns",
       "                         of U (the left singular vectors, stored",
       "                         columnwise) if M >= N;",
       "                         A is overwritten with the first M rows",
       "                         of V**H (the right singular vectors, stored",
       "                         rowwise) otherwise.",
       "         if JOBZ .ne. 'O', the contents of A are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is COMPLEX array, dimension (LDU,UCOL)",
       "         UCOL = M if JOBZ = 'A' or JOBZ = 'O' and M < N;",
       "         UCOL = min(M,N) if JOBZ = 'S'.",
       "         If JOBZ = 'A' or JOBZ = 'O' and M < N, U contains the M-by-M",
       "         unitary matrix U;",
       "         if JOBZ = 'S', U contains the first min(M,N) columns of U",
       "         (the left singular vectors, stored columnwise);",
       "         if JOBZ = 'O' and M >= N, or JOBZ = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1;",
       "         if JOBZ = 'S' or 'A' or JOBZ = 'O' and M < N, LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is COMPLEX array, dimension (LDVT,N)",
       "         If JOBZ = 'A' or JOBZ = 'O' and M >= N, VT contains the",
       "         N-by-N unitary matrix V**H;",
       "         if JOBZ = 'S', VT contains the first min(M,N) rows of",
       "         V**H (the right singular vectors, stored rowwise);",
       "         if JOBZ = 'O' and M < N, or JOBZ = 'N', VT is not referenced."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1;",
       "         if JOBZ = 'A' or JOBZ = 'O' and M >= N, LDVT >= N;",
       "         if JOBZ = 'S', LDVT >= min(M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= 1.",
       "         If LWORK = -1, a workspace query is assumed.  The optimal",
       "         size for the WORK array is calculated and stored in WORK(1),",
       "         and no other work except argument checking is performed.",
       "         Let mx = max(M,N) and mn = min(M,N).",
       "         If JOBZ = 'N', LWORK >= 2*mn + mx.",
       "         If JOBZ = 'O', LWORK >= 2*mn*mn + 2*mn + mx.",
       "         If JOBZ = 'S', LWORK >=   mn*mn + 3*mn.",
       "         If JOBZ = 'A', LWORK >=   mn*mn + 2*mn + mx.",
       "         These are not tight minimums in all cases; see comments inside code.",
       "         For good performance, LWORK should generally be larger;",
       "         a query is recommended."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         Let mx = max(M,N) and mn = min(M,N).",
       "         If JOBZ = 'N',    LRWORK >= 5*mn (LAPACK <= 3.6 needs 7*mn);",
       "         else if mx >> mn, LRWORK >= 5*mn*mn + 5*mn;",
       "         else              LRWORK >= max( 5*mn*mn + 5*mn,",
       "                                          2*mx*mn + 2*mn*mn + mn )."],
     "IWORK"=>
      ["[out]", "         IWORK is INTEGER array, dimension (8*min(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The updating process of SBDSDC did not converge."]}},
 "ctplqt"=>
  {"summary"=>
    ["CTPLQT computes a blocked LQ factorization of a complex",
     "\"triangular-pentagonal\" matrix C, which is composed of a",
     "triangular block A and pentagonal block B, using the compact",
     "WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B, and the order of the",
       "         triangular matrix A.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the lower trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.  M >= MB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the lower triangular N-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the lower triangular matrix L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first N-L columns",
       "         are rectangular, and the last L columns are lower trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,N)",
       "         The lower triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (MB*M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cunglq"=>
  {"summary"=>
    ["CUNGLQ generates an M-by-N complex matrix Q with orthonormal rows,",
     "which is defined as the first M rows of a product of K elementary",
     "reflectors of order N",
     "      Q  =  H(k)**H . . . H(2)**H H(1)**H",
     "as returned by CGELQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the i-th row must contain the vector which defines",
       "         the elementary reflector H(i), for i = 1,2,...,k, as returned",
       "         by CGELQF in the first k rows of its array argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGELQF."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit;",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "zgemlq"=>
  {"summary"=>
    ["    ZGEMLQ overwrites the general real M-by-N matrix C with",
     "                     SIDE = 'L'     SIDE = 'R'",
     "     TRANS = 'N':      Q * C          C * Q",
     "     TRANS = 'C':      Q**H * C       C * Q**H",
     "     where Q is a complex unitary matrix defined as the product",
     "     of blocked elementary reflectors computed by short wide",
     "     LQ factorization (ZGELQ)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         Part of the data structure to represent Q as returned by ZGELQ."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension (MAX(5,TSIZE)).",
       "         Part of the data structure to represent Q as returned by ZGELQ."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         The dimension of the array T. TSIZE >= 5."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "        (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed. The routine",
       "         only calculates the size of the WORK array, returns this",
       "         value as WORK(1), and no error message related to WORK ",
       "         is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zsyrfs"=>
  {"summary"=>
    ["ZSYRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric indefinite, and",
     "provides error bounds and backward error estimates for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "         The factored form of the matrix A.  AF contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**T or",
       "         A = L*D*L**T as computed by ZSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by ZSYTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slantp"=>
  {"summary"=>
    ["SLANTP  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "triangular matrix A, supplied in packed form.",
     "   SLANTP = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANTP as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, SLANTP is",
       "         set to zero."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         Note that when DIAG = 'U', the elements of the array AP",
       "         corresponding to the diagonal elements of the matrix A are",
       "         not referenced, but are assumed to be one."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "dgges"=>
  {"summary"=>
    ["DGGES computes for a pair of N-by-N real nonsymmetric matrices (A,B),",
     "the generalized eigenvalues, the generalized real Schur form (S,T),",
     "optionally, the left and/or right matrices of Schur vectors (VSL and",
     "VSR). This gives the generalized Schur factorization",
     "         (A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T )",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "quasi-triangular matrix S and the upper triangular matrix T.The",
     "leading columns of VSL and VSR then form an orthonormal basis for the",
     "corresponding left and right eigenspaces (deflating subspaces).",
     "(If only the generalized eigenvalues are needed, use the driver",
     "DGGEV instead, which is faster.)",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0 or both being zero.",
     "A pair of matrices (S,T) is in generalized real Schur form if T is",
     "upper triangular with non-negative diagonal and S is block upper",
     "triangular with 1-by-1 and 2-by-2 blocks.  1-by-1 blocks correspond",
     "to real generalized eigenvalues, while 2-by-2 blocks of S will be",
     "\"standardized\" by making the corresponding elements of T have the",
     "form:",
     "        [  a  0  ]",
     "        [  0  b  ]",
     "and the pair of corresponding 2-by-2 blocks in S and T will have a",
     "complex conjugate pair of generalized eigenvalues."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG);"],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is a LOGICAL FUNCTION of three DOUBLE PRECISION arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         An eigenvalue (ALPHAR(j)+ALPHAI(j))/BETA(j) is selected if",
       "         SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) is true; i.e. if either",
       "         one of a complex conjugate pair of eigenvalues is selected,",
       "         then both complex eigenvalues are selected.",
       "         Note that in the ill-conditioned case, a selected complex",
       "         eigenvalue may no longer satisfy SELCTG(ALPHAR(j),ALPHAI(j),",
       "         BETA(j)) = .TRUE. after ordering. INFO is to be set to N+2",
       "         in this case."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true.  (Complex conjugate pairs for which",
       "         SELCTG is true for either eigenvalue count as 2.)"],
     "ALPHAR"=>
      ["[out]", "         ALPHAR is DOUBLE PRECISION array, dimension (N)"],
     "ALPHAI"=>
      ["[out]", "         ALPHAI is DOUBLE PRECISION array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  ALPHAR(j) + ALPHAI(j)*i,",
       "         and  BETA(j),j=1,...,N are the diagonals of the complex Schur",
       "         form (S,T) that would result if the 2-by-2 diagonal blocks of",
       "         the real Schur form of (A,B) were further reduced to",
       "         triangular form using 2-by-2 complex unitary transformations.",
       "         If ALPHAI(j) is zero, then the j-th eigenvalue is real; if",
       "         positive, then the j-th and (j+1)-st eigenvalues are a",
       "         complex conjugate pair, with ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio.",
       "         However, ALPHAR and ALPHAI will be always less than and",
       "         usually comparable with norm(A) in magnitude, and BETA always",
       "         less than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is DOUBLE PRECISION array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >=1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is DOUBLE PRECISION array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N = 0, LWORK >= 1, else LWORK >= 8*N+16.",
       "         For good performance , LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHAR(j), ALPHAI(j), and BETA(j) should",
       "               be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in DHGEQZ.",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in DTGSEN."]}},
 "zhpsvx"=>
  {"summary"=>
    ["ZHPSVX uses the diagonal pivoting factorization A = U*D*U**H or",
     "A = L*D*L**H to compute the solution to a complex system of linear",
     "equations A * X = B, where A is an N-by-N Hermitian matrix stored",
     "in packed format and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "cgebak"=>
  {"summary"=>
    ["CGEBAK forms the right or left eigenvectors of a complex general",
     "matrix by backward transformation on the computed eigenvectors of the",
     "balanced matrix output by CGEBAL."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the type of backward transformation required:",
       "         = 'N', do nothing, return immediately;",
       "         = 'P', do backward transformation for permutation only;",
       "         = 'S', do backward transformation for scaling only;",
       "         = 'B', do backward transformations for both permutation and",
       "                scaling.",
       "         JOB must be the same as the argument JOB supplied to CGEBAL."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  V contains right eigenvectors;",
       "         = 'L':  V contains left eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrix V.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         The integers ILO and IHI determined by CGEBAL.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "SCALE"=>
      ["[in]",
       "         SCALE is REAL array, dimension (N)",
       "         Details of the permutation and scaling factors, as returned",
       "         by CGEBAL."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix V.  M >= 0."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX array, dimension (LDV,M)",
       "         On entry, the matrix of right or left eigenvectors to be",
       "         transformed, as returned by CHSEIN or CTREVC.",
       "         On exit, V is overwritten by the transformed eigenvectors."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "chbev"=>
  {"summary"=>
    ["CHBEV computes all the eigenvalues and, optionally, eigenvectors of",
     "a complex Hermitian band matrix A."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "RWORK"=>
      ["[out]", "         RWORK is REAL array, dimension (max(1,3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "zgerqf"=>
  {"summary"=>
    ["ZGERQF computes an RQ factorization of a complex M-by-N matrix A:",
     "A = R * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if m <= n, the upper triangle of the subarray",
       "         A(1:m,n-m+1:n) contains the M-by-M upper triangular matrix R;",
       "         if m >= n, the elements on and above the (m-n)-th subdiagonal",
       "         contain the M-by-N upper trapezoidal matrix R;",
       "         the remaining elements, with the array TAU, represent the",
       "         unitary matrix Q as a product of min(m,n) elementary",
       "         reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chprfs"=>
  {"summary"=>
    ["CHPRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian indefinite",
     "and packed, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the Hermitian matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n."],
     "AFP"=>
      ["[in]",
       "         AFP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The factored form of the matrix A.  AFP contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**H or",
       "         A = L*D*L**H as computed by CHPTRF, stored as a packed",
       "         triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHPTRF."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by CHPTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ssyconvf_rook"=>
  {"summary"=>
    ["If parameter WAY = 'C':",
     "SSYCONVF_ROOK converts the factorization output format used in",
     "SSYTRF_ROOK provided on entry in parameter A into the factorization",
     "output format used in SSYTRF_RK (or SSYTRF_BK) that is stored",
     "on exit in parameters A and E. IPIV format for SSYTRF_ROOK and",
     "SSYTRF_RK (or SSYTRF_BK) is the same and is not converted.",
     "If parameter WAY = 'R':",
     "SSYCONVF_ROOK performs the conversion in reverse direction, i.e.",
     "converts the factorization output format used in SSYTRF_RK",
     "(or SSYTRF_BK) provided on entry in parametes A and E into",
     "the factorization output format used in SSYTRF_ROOK that is stored",
     "on exit in parameter A. IPIV format for SSYTRF_ROOK and",
     "SSYTRF_RK (or SSYTRF_BK) is the same and is not converted."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix A.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         1) If WAY ='C':",
       "         On entry, contains factorization details in format used in",
       "         SSYTRF_ROOK:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         SSYTRF_RK or SSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         2) If WAY = 'R':",
       "         On entry, contains factorization details in format used in",
       "         SSYTRF_RK or SSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         SSYTRF_ROOK:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, just a workspace.",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         2) If WAY = 'R':",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not referenced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         On exit, is not changed"],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On entry, details of the interchanges and the block",
       "         structure of D as determined:",
       "         1) by SSYTRF_ROOK, if WAY ='C';",
       "         2) by SSYTRF_RK (or SSYTRF_BK), if WAY ='R'.",
       "         The IPIV format is the same for all these routines.",
       "         On exit, is not changed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sppequ"=>
  {"summary"=>
    ["SPPEQU computes row and column scalings intended to equilibrate a",
     "symmetric positive definite matrix A in packed storage and reduce",
     "its condition number (with respect to the two-norm).  S contains the",
     "scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix",
     "B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal.",
     "This choice of S puts the condition number of B within a factor N of",
     "the smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is REAL",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "sorgl2"=>
  {"summary"=>
    ["SORGL2 generates an m by n real matrix Q with orthonormal rows,",
     "which is defined as the first m rows of a product of k elementary",
     "reflectors of order n",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by SGELQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the i-th row must contain the vector which defines",
       "         the elementary reflector H(i), for i = 1,2,...,k, as returned",
       "         by SGELQF in the first k rows of its array argument A.",
       "         On exit, the m-by-n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGELQF."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "ctpttr"=>
  {"summary"=>
    ["CTPTTR copies a triangular matrix A from standard packed format (TP)",
     "to standard full format (TR)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular.",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "A"=>
      ["[out]",
       "         A is COMPLEX array, dimension ( LDA, N )",
       "         On exit, the triangular matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chesvx"=>
  {"summary"=>
    ["CHESVX uses the diagonal pivoting factorization to compute the",
     "solution to a complex system of linear equations A * X = B,",
     "where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS",
     "matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "sgbcon"=>
  {"summary"=>
    ["SGBCON estimates the reciprocal of the condition number of a real",
     "general band matrix A, in either the 1-norm or the infinity-norm,",
     "using the LU factorization computed by SGBTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by SGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= N, row i of the matrix was",
       "         interchanged with row IPIV(i)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "cla_herpvgrw"=>
  {"summary"=>
    ["CLA_HERPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "INFO"=>
      ["[in]",
       "         INFO is INTEGER",
       "    The value of INFO returned from SSYTRF, .i.e., the pivot in",
       "    column INFO is exactly 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by CHETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by CHETRF."],
     "WORK"=>["[in]", "         WORK is REAL array, dimension (2*N)"]}},
 "cpprfs"=>
  {"summary"=>
    ["CPPRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian positive definite",
     "and packed, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the Hermitian matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "AFP"=>
      ["[in]",
       "         AFP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H, as computed by SPPTRF/CPPTRF,",
       "         packed columnwise in a linear array in the same format as A",
       "         (see AP)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by CPPTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dtgexc"=>
  {"summary"=>
    ["DTGEXC reorders the generalized real Schur decomposition of a real",
     "matrix pair (A,B) using an orthogonal equivalence transformation",
     "               (A, B) = Q * (A, B) * Z**T,",
     "so that the diagonal block of (A, B) with row index IFST is moved",
     "to row ILST.",
     "(A, B) must be in generalized real Schur canonical form (as returned",
     "by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2",
     "diagonal blocks. B is upper triangular.",
     "Optionally, the matrices Q and Z of generalized Schur vectors are",
     "updated.",
     "       Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T",
     "       Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T"],
   "param"=>
    {"WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the matrix A in generalized real Schur canonical",
       "         form.",
       "         On exit, the updated matrix A, again in generalized",
       "         real Schur canonical form."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the matrix B in generalized real Schur canonical",
       "         form (A,B).",
       "         On exit, the updated matrix B, again in generalized",
       "         real Schur canonical form (A,B)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         On entry, if WANTQ = .TRUE., the orthogonal matrix Q.",
       "         On exit, the updated matrix Q.",
       "         If WANTQ = .FALSE., Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= 1.",
       "         If WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ,N)",
       "         On entry, if WANTZ = .TRUE., the orthogonal matrix Z.",
       "         On exit, the updated matrix Z.",
       "         If WANTZ = .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1.",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "IFST"=>["[in,out]", "         IFST is INTEGER"],
     "ILST"=>
      ["[in,out]",
       "         ILST is INTEGER",
       "         Specify the reordering of the diagonal blocks of (A, B).",
       "         The block with row index IFST is moved to row ILST, by a",
       "         sequence of swapping between adjacent blocks.",
       "         On exit, if IFST pointed on entry to the second row of",
       "         a 2-by-2 block, it is changed to point to the first row;",
       "         ILST always points to the first row of the block in its",
       "         final position (which may differ from its input value by",
       "         +1 or -1). 1 <= IFST, ILST <= N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= 1 when N <= 1, otherwise LWORK >= 4*N + 16.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          =0:  successful exit.",
       "          <0:  if INFO = -i, the i-th argument had an illegal value.",
       "          =1:  The transformed matrix pair (A, B) would be too far",
       "               from generalized Schur form; the problem is ill-",
       "               conditioned. (A, B) may have been partially reordered,",
       "               and ILST points to the first row of the current",
       "               position of the block being moved."]}},
 "ssytd2"=>
  {"summary"=>
    ["SSYTD2 reduces a real symmetric matrix A to symmetric tridiagonal",
     "form T by an orthogonal similarity transformation: Q**T * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the orthogonal",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the orthogonal matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dlaqr0"=>
  {"summary"=>
    ["   DLAQR0 computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**T, where T is an upper quasi-triangular matrix (the",
     "   Schur form), and Z is the orthogonal matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input orthogonal",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the orthogonal matrix Q:  A = Q*H*Q**T = (QZ)*T*(QZ)**T."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N and, if ILO.GT.1,",
       "          H(ILO,ILO-1) is zero. ILO and IHI are normally set by a",
       "          previous call to DGEBAL, and then passed to DGEHRD when the",
       "          matrix output by DGEBAL is reduced to Hessenberg form.",
       "          Otherwise, ILO and IHI should be set to 1 and N,",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is DOUBLE PRECISION array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and WANTT is .TRUE., then H contains",
       "          the upper quasi-triangular matrix T from the Schur",
       "          decomposition (the Schur form); 2-by-2 diagonal blocks",
       "          (corresponding to complex conjugate pairs of eigenvalues)",
       "          are returned in standard form, with H(i,i) = H(i+1,i+1)",
       "          and H(i+1,i)*H(i,i+1).LT.0. If INFO = 0 and WANTT is",
       "          .FALSE., then the contents of H are unspecified on exit.",
       "          (The output value of H when INFO.GT.0 is given under the",
       "          description of INFO below.)",
       "          This subroutine may explicitly set H(i,j) = 0 for i.GT.j and",
       "          j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "WR"=>["[out]", "         WR is DOUBLE PRECISION array, dimension (IHI)"],
     "WI"=>
      ["[out]",
       "         WI is DOUBLE PRECISION array, dimension (IHI)",
       "          The real and imaginary parts, respectively, of the computed",
       "          eigenvalues of H(ILO:IHI,ILO:IHI) are stored in WR(ILO:IHI)",
       "          and WI(ILO:IHI). If two eigenvalues are computed as a",
       "          complex conjugate pair, they are stored in consecutive",
       "          elements of WR and WI, say the i-th and (i+1)th, with",
       "          WI(i) .GT. 0 and WI(i+1) .LT. 0. If WANTT is .TRUE., then",
       "          the eigenvalues are stored in the same order as on the",
       "          diagonal of the Schur form returned in H, with",
       "          WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2 diagonal",
       "          block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and",
       "          WI(i+1) = -WI(i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "          Specify the rows of Z to which transformations must be",
       "          applied if WANTZ is .TRUE..",
       "          1 .LE. ILOZ .LE. ILO; IHI .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ,IHI)",
       "          If WANTZ is .FALSE., then Z is not referenced.",
       "          If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is",
       "          replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the",
       "          orthogonal Schur factor of H(ILO:IHI,ILO:IHI).",
       "          (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if WANTZ is .TRUE.",
       "          then LDZ.GE.MAX(1,IHIZ).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension LWORK",
       "          On exit, if LWORK = -1, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient, but LWORK typically as large as 6*N may",
       "          be required for optimal performance.  A workspace query",
       "          to determine the optimal workspace size is recommended.",
       "          If LWORK = -1, then DLAQR0 does a workspace query.",
       "          In this case, DLAQR0 checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .GT. 0:  if INFO = i, DLAQR0 failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and WANT is .FALSE., then on exit,",
       "               the remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is an orthogonal matrix.  The final",
       "               value of H is upper Hessenberg and quasi-triangular",
       "               in rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                 (final value of Z(ILO:IHI,ILOZ:IHIZ)",
       "                  =  (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U",
       "               where U is the orthogonal matrix in (*) (regard-",
       "               less of the value of WANTT.)",
       "               If INFO .GT. 0 and WANTZ is .FALSE., then Z is not",
       "               accessed."]}},
 "zsteqr"=>
  {"summary"=>
    ["ZSTEQR computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric tridiagonal matrix using the implicit QL or QR method.",
     "The eigenvectors of a full or band complex Hermitian matrix can also",
     "be found if ZHETRD or ZHPTRD or ZHBTRD has been used to reduce this",
     "matrix to tridiagonal form."],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'V':  Compute eigenvalues and eigenvectors of the original",
       "                 Hermitian matrix.  On entry, Z must contain the",
       "                 unitary matrix used to reduce the original matrix",
       "                 to tridiagonal form.",
       "         = 'I':  Compute eigenvalues and eigenvectors of the",
       "                 tridiagonal matrix.  Z is initialized to the identity",
       "                 matrix."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the diagonal elements of the tridiagonal matrix.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         On entry, if  COMPZ = 'V', then Z contains the unitary",
       "         matrix used in the reduction to tridiagonal form.",
       "         On exit, if INFO = 0, then if COMPZ = 'V', Z contains the",
       "         orthonormal eigenvectors of the original Hermitian matrix,",
       "         and if COMPZ = 'I', Z contains the orthonormal eigenvectors",
       "         of the symmetric tridiagonal matrix.",
       "         If COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         eigenvectors are desired, then  LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (max(1,2*N-2))",
       "         If COMPZ = 'N', then WORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  the algorithm has failed to find all the eigenvalues in",
       "               a total of 30*N iterations; if INFO = i, then i",
       "               elements of E have not converged to zero; on exit, D",
       "               and E contain the elements of a symmetric tridiagonal",
       "               matrix which is unitarily similar to the original",
       "               matrix."]}},
 "csyswapr"=>
  {"summary"=>
    ["CSYSWAPR applies an elementary permutation on the rows and the columns of",
     "a symmetric matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "I1"=>
      ["[in]",
       "         I1 is INTEGER",
       "         Index of the first row to swap"],
     "I2"=>
      ["[in]",
       "         I2 is INTEGER",
       "         Index of the second row to swap"]}},
 "sla_lin_berr"=>
  {"summary"=>
    ["   SLA_LIN_BERR computes componentwise relative backward error from",
     "   the formula",
     "       max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
     "   where abs(Z) is the componentwise absolute value of the matrix",
     "   or vector Z."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NZ"=>
      ["[in]",
       "         NZ is INTEGER",
       "    We add (NZ+1)*SLAMCH( 'Safe minimum' ) to R(i) in the numerator to",
       "    guard against spuriously zero residuals. Default value is N."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices AYB, RES, and BERR.  NRHS >= 0."],
     "RES"=>
      ["[in]",
       "         RES is REAL array, dimension (N,NRHS)",
       "    The residual matrix, i.e., the matrix R in the relative backward",
       "    error formula above."],
     "AYB"=>
      ["[in]",
       "         AYB is REAL array, dimension (N, NRHS)",
       "    The denominator in the relative backward error formula above, i.e.,",
       "    the matrix abs(op(A_s))*abs(Y) + abs(B_s). The matrices A, Y, and B",
       "    are from iterative refinement (see sla_gerfsx_extended.f)."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "    The componentwise relative backward error from the formula above."]}},
 "csytri_rook"=>
  {"summary"=>
    ["CSYTRI_ROOK computes the inverse of a complex symmetric",
     "matrix A using the factorization A = U*D*U**T or A = L*D*L**T",
     "computed by CSYTRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CSYTRF_ROOK.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF_ROOK."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "zungbr"=>
  {"summary"=>
    ["ZUNGBR generates one of the complex unitary matrices Q or P**H",
     "determined by ZGEBRD when reducing a complex matrix A to bidiagonal",
     "form: A = Q * B * P**H.  Q and P**H are defined as products of",
     "elementary reflectors H(i) or G(i) respectively.",
     "If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q",
     "is of order M:",
     "if m >= k, Q = H(1) H(2) . . . H(k) and ZUNGBR returns the first n",
     "columns of Q, where m >= n >= k;",
     "if m < k, Q = H(1) H(2) . . . H(m-1) and ZUNGBR returns Q as an",
     "M-by-M matrix.",
     "If VECT = 'P', A is assumed to have been a K-by-N matrix, and P**H",
     "is of order N:",
     "if k < n, P**H = G(k) . . . G(2) G(1) and ZUNGBR returns the first m",
     "rows of P**H, where n >= m >= k;",
     "if k >= n, P**H = G(n-1) . . . G(2) G(1) and ZUNGBR returns P**H as",
     "an N-by-N matrix."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         Specifies whether the matrix Q or the matrix P**H is",
       "         required, as defined in the transformation applied by ZGEBRD:",
       "         = 'Q':  generate Q;",
       "         = 'P':  generate P**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q or P**H to be returned.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q or P**H to be returned.",
       "         N >= 0.",
       "         If VECT = 'Q', M >= N >= min(M,K);",
       "         if VECT = 'P', N >= M >= min(N,K)."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         If VECT = 'Q', the number of columns in the original M-by-K",
       "         matrix reduced by ZGEBRD.",
       "         If VECT = 'P', the number of rows in the original K-by-N",
       "         matrix reduced by ZGEBRD.",
       "         K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by ZGEBRD.",
       "         On exit, the M-by-N matrix Q or P**H."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= M."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension",
       "                               (min(M,K)) if VECT = 'Q'",
       "                               (min(N,K)) if VECT = 'P'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i) or G(i), which determines Q or P**H, as",
       "         returned by ZGEBRD in its array argument TAUQ or TAUP."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,min(M,N)).",
       "         For optimum performance LWORK >= min(M,N)*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "csysvxx"=>
  {"summary"=>
    ["   CSYSVXX uses the diagonal pivoting factorization to compute the",
     "   solution to a complex system of linear equations A * X = B, where",
     "   A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "   matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. CSYSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   CSYSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   CSYSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what CSYSVXX would itself produce."],
   "param"=>nil},
 "zungrq"=>
  {"summary"=>
    ["ZUNGRQ generates an M-by-N complex matrix Q with orthonormal rows,",
     "which is defined as the last M rows of a product of K elementary",
     "reflectors of order N",
     "      Q  =  H(1)**H H(2)**H . . . H(k)**H",
     "as returned by ZGERQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the (m-k+i)-th row must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by ZGERQF in the last k rows of its array argument",
       "         A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGERQF."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "strcon"=>
  {"summary"=>
    ["STRCON estimates the reciprocal of the condition number of a",
     "triangular matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgttrf"=>
  {"summary"=>
    ["CGTTRF computes an LU factorization of a complex tridiagonal matrix A",
     "using elimination with partial pivoting and row interchanges.",
     "The factorization has the form",
     "   A = L * U",
     "where L is a product of permutation and unit lower bidiagonal",
     "matrices and U is upper triangular with nonzeros in only the main",
     "diagonal and first two superdiagonals."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "DL"=>
      ["[in,out]",
       "         DL is COMPLEX array, dimension (N-1)",
       "         On entry, DL must contain the (n-1) sub-diagonal elements of",
       "         A.",
       "         On exit, DL is overwritten by the (n-1) multipliers that",
       "         define the matrix L from the LU factorization of A."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX array, dimension (N)",
       "         On entry, D must contain the diagonal elements of A.",
       "         On exit, D is overwritten by the n diagonal elements of the",
       "         upper triangular matrix U from the LU factorization of A."],
     "DU"=>
      ["[in,out]",
       "         DU is COMPLEX array, dimension (N-1)",
       "         On entry, DU must contain the (n-1) super-diagonal elements",
       "         of A.",
       "         On exit, DU is overwritten by the (n-1) elements of the first",
       "         super-diagonal of U."],
     "DU2"=>
      ["[out]",
       "         DU2 is COMPLEX array, dimension (N-2)",
       "         On exit, DU2 is overwritten by the (n-2) elements of the",
       "         second super-diagonal of U."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value",
       "         > 0:  if INFO = k, U(k,k) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "clarfy"=>
  {"summary"=>
    ["CLARFY applies an elementary reflector, or Householder matrix, H,",
     "to an n x n Hermitian matrix C, from both the left and the right.",
     "H is represented in the form",
     "   H = I - tau * v * v'",
     "where  tau  is a scalar and  v  is a vector.",
     "If  tau  is  zero, then  H  is taken to be the unit matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix C is stored.",
       "         = 'U':  Upper triangle",
       "         = 'L':  Lower triangle"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows and columns of the matrix C.  N >= 0."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension",
       "                 (1 + (N-1)*abs(INCV))",
       "         The vector v as described above."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between successive elements of v.  INCV must",
       "         not be zero."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX",
       "         The value tau as described above."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC, N)",
       "         On entry, the matrix C.",
       "         On exit, C is overwritten by H * C * H'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.  LDC >= max( 1, N )."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"]}},
 "zsyconvf"=>
  {"summary"=>
    ["If parameter WAY = 'C':",
     "ZSYCONVF converts the factorization output format used in",
     "ZSYTRF provided on entry in parameter A into the factorization",
     "output format used in ZSYTRF_RK (or ZSYTRF_BK) that is stored",
     "on exit in parameters A and E. It also coverts in place details of",
     "the intechanges stored in IPIV from the format used in ZSYTRF into",
     "the format used in ZSYTRF_RK (or ZSYTRF_BK).",
     "If parameter WAY = 'R':",
     "ZSYCONVF performs the conversion in reverse direction, i.e.",
     "converts the factorization output format used in ZSYTRF_RK",
     "(or ZSYTRF_BK) provided on entry in parametes A and E into",
     "the factorization output format used in ZSYTRF that is stored",
     "on exit in parameter A. It also coverts in place details of",
     "the intechanges stored in IPIV from the format used in ZSYTRF_RK",
     "(or ZSYTRF_BK) into the format used in ZSYTRF.",
     "ZSYCONVF can also convert in Hermitian matrix case, i.e. between",
     "formats used in ZHETRF and ZHETRF_RK (or ZHETRF_BK)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix A.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         1) If WAY ='C':",
       "         On entry, contains factorization details in format used in",
       "         ZSYTRF:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         ZSYTRF_RK or ZSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         2) If WAY = 'R':",
       "         On entry, contains factorization details in format used in",
       "         ZSYTRF_RK or ZSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         ZSYTRF:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in,out]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, just a workspace.",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         2) If WAY = 'R':",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not referenced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         On exit, is not changed"],
     "IPIV"=>
      ["[in,out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, details of the interchanges and the block",
       "         structure of D in the format used in ZSYTRF.",
       "         On exit, details of the interchanges and the block",
       "         structure of D in the format used in ZSYTRF_RK",
       "         ( or ZSYTRF_BK).",
       "         1) If WAY ='R':",
       "         On entry, details of the interchanges and the block",
       "         structure of D in the format used in ZSYTRF_RK",
       "         ( or ZSYTRF_BK).",
       "         On exit, details of the interchanges and the block",
       "         structure of D in the format used in ZSYTRF."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgerfsx"=>
  {"summary"=>
    ["   CGERFSX improves the computed solution to a system of linear",
     "   equations and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED, R",
     "   and C below. In this case, the solution and error bounds returned",
     "   are for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "              diag(R).",
       "      = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "              by diag(C).",
       "      = 'B':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(R) * A * diag(C).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    The original N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The factors L and U from the factorization A = P*L*U",
       "    as computed by CGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from CGETRF; for 1<=i<=N, row i of the",
       "    matrix was interchanged with row IPIV(i)."],
     "R"=>
      ["[in]",
       "         R is REAL array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'R' or 'B', A is",
       "    multiplied on the left by diag(R); if EQUED = 'N' or 'C', R",
       "    is not accessed.",
       "    If R is accessed, each element of R should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A.  If EQUED = 'C' or 'B', A is",
       "    multiplied on the right by diag(C); if EQUED = 'N' or 'R', C",
       "    is not accessed.",
       "    If C is accessed, each element of C should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by CGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is REAL array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "csytrs_3"=>
  {"summary"=>
    ["CSYTRS_3 solves a system of linear equations A * X = B with a complex",
     "symmetric matrix A using the factorization computed",
     "by CSYTRF_RK or CSYTRF_BK:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This algorithm is using Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**T)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**T)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by CSYTRF_RK and CSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF_RK or CSYTRF_BK."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgbequb"=>
  {"summary"=>
    ["CGBEQUB computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most",
     "the radix.",
     "R(i) and C(j) are restricted to be a power of the radix between",
     "SMLNUM = smallest safe number and BIGNUM = largest safe number.  Use",
     "of these scaling factors is not guaranteed to reduce the condition",
     "number of A but works well in practice.",
     "This routine differs from CGEEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled entries' magnitudes are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A.  LDAB >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is REAL array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is REAL array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is REAL",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is REAL",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "dtgevc"=>
  {"summary"=>
    ["DTGEVC computes some or all of the right and/or left eigenvectors of",
     "a pair of real matrices (S,P), where S is a quasi-triangular matrix",
     "and P is upper triangular.  Matrix pairs of this type are produced by",
     "the generalized Schur factorization of a matrix pair (A,B):",
     "   A = Q*S*Z**T,  B = Q*P*Z**T",
     "as computed by DGGHRD + DHGEQZ.",
     "The right eigenvector x and the left eigenvector y of (S,P)",
     "corresponding to an eigenvalue w are defined by:",
     "   S*x = w*P*x,  (y**H)*S = w*(y**H)*P,",
     "where y**H denotes the conjugate tranpose of y.",
     "The eigenvalues are not input to this routine, but are computed",
     "directly from the diagonal blocks of S and P.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of (S,P), or the products Z*X and/or Q*Y,",
     "where Z and Q are input matrices.",
     "If Q and Z are the orthogonal factors from the generalized Schur",
     "factorization of a matrix pair (A,B), then Z*X and Q*Y",
     "are the matrices of right and left eigenvectors of (A,B)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R': compute right eigenvectors only;",
       "         = 'L': compute left eigenvectors only;",
       "         = 'B': compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute all right and/or left eigenvectors;",
       "         = 'B': compute all right and/or left eigenvectors,",
       "                backtransformed by the matrices in VR and/or VL;",
       "         = 'S': compute selected right and/or left eigenvectors,",
       "                specified by the logical array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY='S', SELECT specifies the eigenvectors to be",
       "         computed.  If w(j) is a real eigenvalue, the corresponding",
       "         real eigenvector is computed if SELECT(j) is .TRUE..",
       "         If w(j) and w(j+1) are the real and imaginary parts of a",
       "         complex eigenvalue, the corresponding complex eigenvector",
       "         is computed if either SELECT(j) or SELECT(j+1) is .TRUE.,",
       "         and on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is",
       "         set to .FALSE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices S and P.  N >= 0."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension (LDS,N)",
       "         The upper quasi-triangular matrix S from a generalized Schur",
       "         factorization, as computed by DHGEQZ."],
     "LDS"=>
      ["[in]",
       "         LDS is INTEGER",
       "         The leading dimension of array S.  LDS >= max(1,N)."],
     "P"=>
      ["[in]",
       "         P is DOUBLE PRECISION array, dimension (LDP,N)",
       "         The upper triangular matrix P from a generalized Schur",
       "         factorization, as computed by DHGEQZ.",
       "         2-by-2 diagonal blocks of P corresponding to 2-by-2 blocks",
       "         of S must be in positive diagonal form."],
     "LDP"=>
      ["[in]",
       "         LDP is INTEGER",
       "         The leading dimension of array P.  LDP >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is DOUBLE PRECISION array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the orthogonal matrix Q",
       "         of left Schur vectors returned by DHGEQZ).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of (S,P);",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of (S,P) specified by",
       "                     SELECT, stored consecutively in the columns of",
       "                     VL, in the same order as their eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part, and the second the imaginary part.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of array VL.  LDVL >= 1, and if",
       "         SIDE = 'L' or 'B', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is DOUBLE PRECISION array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Z (usually the orthogonal matrix Z",
       "         of right Schur vectors returned by DHGEQZ).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of (S,P);",
       "         if HOWMNY = 'B' or 'b', the matrix Z*X;",
       "         if HOWMNY = 'S' or 's', the right eigenvectors of (S,P)",
       "                     specified by SELECT, stored consecutively in the",
       "                     columns of VR, in the same order as their",
       "                     eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part and the second the imaginary part.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1, and if",
       "         SIDE = 'R' or 'B', LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.  If HOWMNY = 'A' or 'B', M",
       "         is set to N.  Each selected real eigenvector occupies one",
       "         column and each selected complex eigenvector occupies two",
       "         columns."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (6*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  the 2-by-2 block (INFO:INFO+1) does not have a complex",
       "               eigenvalue."]}},
 "clansb"=>
  {"summary"=>
    ["CLANSB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n symmetric band matrix A,  with k super-diagonals.",
     "   CLANSB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANSB as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         band matrix A is supplied.",
       "         = 'U':  Upper triangular part is supplied",
       "         = 'L':  Lower triangular part is supplied"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANSB is",
       "         set to zero."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of super-diagonals or sub-diagonals of the",
       "         band matrix A.  K >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The upper or lower triangle of the symmetric band matrix A,",
       "         stored in the first K+1 rows of AB.  The j-th column of A is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)   = A(i,j) for j<=i<=min(n,j+k)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= K+1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "dgejsv"=>
  {"summary"=>
    ["DGEJSV computes the singular value decomposition (SVD) of a real M-by-N",
     "matrix [A], where M >= N. The SVD of [A] is written as",
     "             [A] = [U] * [SIGMA] * [V]^t,",
     "where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N",
     "diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and",
     "[V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are",
     "the singular values of [A]. The columns of [U] and [V] are the left and",
     "the right singular vectors of [A], respectively. The matrices [U] and [V]",
     "are computed and stored in the arrays U and V, respectively. The diagonal",
     "of [SIGMA] is computed and stored in the array SVA.",
     "DGEJSV can sometimes compute tiny singular values and their singular vectors much",
     "more accurately than other SVD routines, see below under Further Details."],
   "param"=>
    {"JOBA"=>
      ["[in]",
       "         JOBA is CHARACTER*1",
       "       Specifies the level of accuracy:",
       "      = 'C': This option works well (high relative accuracy) if A = B * D,",
       "            with well-conditioned B and arbitrary diagonal matrix D.",
       "            The accuracy cannot be spoiled by COLUMN scaling. The",
       "            accuracy of the computed output depends on the condition of",
       "            B, and the procedure aims at the best theoretical accuracy.",
       "            The relative error max_{i=1:N}|d sigma_i| / sigma_i is",
       "            bounded by f(M,N)*epsilon* cond(B), independent of D.",
       "            The input matrix is preprocessed with the QRF with column",
       "            pivoting. This initial preprocessing and preconditioning by",
       "            a rank revealing QR factorization is common for all values of",
       "            JOBA. Additional actions are specified as follows:",
       "      = 'E': Computation as with 'C' with an additional estimate of the",
       "            condition number of B. It provides a realistic error bound.",
       "      = 'F': If A = D1 * C * D2 with ill-conditioned diagonal scalings",
       "            D1, D2, and well-conditioned matrix C, this option gives",
       "            higher accuracy than the 'C' option. If the structure of the",
       "            input matrix is not known, and relative accuracy is",
       "            desirable, then this option is advisable. The input matrix A",
       "            is preprocessed with QR factorization with FULL (row and",
       "            column) pivoting.",
       "      = 'G'  Computation as with 'F' with an additional estimate of the",
       "            condition number of B, where A=D*B. If A has heavily weighted",
       "            rows, then using this condition number gives too pessimistic",
       "            error bound.",
       "      = 'A': Small singular values are the noise and the matrix is treated",
       "            as numerically rank deficient. The error in the computed",
       "            singular values is bounded by f(m,n)*epsilon*||A||.",
       "            The computed SVD A = U * S * V^t restores A up to",
       "            f(m,n)*epsilon*||A||.",
       "            This gives the procedure the licence to discard (set to zero)",
       "            all singular values below N*epsilon*||A||.",
       "      = 'R': Similar as in 'A'. Rank revealing property of the initial",
       "            QR factorization is used do reveal (using triangular factor)",
       "            a gap sigma_{r+1} < epsilon * sigma_r in which case the",
       "            numerical RANK is declared to be r. The SVD is computed with",
       "            absolute error bounds, but more accurately than with 'A'."],
     "JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "       Specifies whether to compute the columns of U:",
       "      = 'U': N columns of U are returned in the array U.",
       "      = 'F': full set of M left sing. vectors is returned in the array U.",
       "      = 'W': U may be used as workspace of length M*N. See the description",
       "            of U.",
       "      = 'N': U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "       Specifies whether to compute the matrix V:",
       "      = 'V': N columns of V are returned in the array V; Jacobi rotations",
       "            are not explicitly accumulated.",
       "      = 'J': N columns of V are returned in the array V, but they are",
       "            computed as the product of Jacobi rotations. This option is",
       "            allowed only if JOBU .NE. 'N', i.e. in computing the full SVD.",
       "      = 'W': V may be used as workspace of length N*N. See the description",
       "            of V.",
       "      = 'N': V is not computed."],
     "JOBR"=>
      ["[in]",
       "         JOBR is CHARACTER*1",
       "       Specifies the RANGE for the singular values. Issues the licence to",
       "       set to zero small positive singular values if they are outside",
       "       specified range. If A .NE. 0 is scaled so that the largest singular",
       "       value of c*A is around DSQRT(BIG), BIG=SLAMCH('O'), then JOBR issues",
       "       the licence to kill columns of A whose norm in c*A is less than",
       "       DSQRT(SFMIN) (for JOBR.EQ.'R'), or less than SMALL=SFMIN/EPSLN,",
       "       where SFMIN=SLAMCH('S'), EPSLN=SLAMCH('E').",
       "      = 'N': Do not kill small columns of c*A. This option assumes that",
       "            BLAS and QR factorizations and triangular solvers are",
       "            implemented to work in that range. If the condition of A",
       "            is greater than BIG, use DGESVJ.",
       "      = 'R': RESTRICTED range for sigma(c*A) is [DSQRT(SFMIN), DSQRT(BIG)]",
       "            (roughly, as described above). This option is recommended.",
       "                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~",
       "       For computing the singular values in the FULL range [SFMIN,BIG]",
       "       use DGESVJ."],
     "JOBT"=>
      ["[in]",
       "         JOBT is CHARACTER*1",
       "       If the matrix is square then the procedure may determine to use",
       "       transposed A if A^t seems to be better with respect to convergence.",
       "       If the matrix is not square, JOBT is ignored. This is subject to",
       "       changes in the future.",
       "       The decision is based on two values of entropy over the adjoint",
       "       orbit of A^t * A. See the descriptions of WORK(6) and WORK(7).",
       "      = 'T': transpose if entropy test indicates possibly faster",
       "       convergence of Jacobi process if A^t is taken as input. If A is",
       "       replaced with A^t, then the row pivoting is included automatically.",
       "      = 'N': do not speculate.",
       "       This option can be used to compute only the singular values, or the",
       "       full SVD (U, SIGMA and V). For only one set of singular vectors",
       "       (U or V), the caller should provide both U and V, as one of the",
       "       matrices is used as workspace if the matrix A is transposed.",
       "       The implementer can easily remove this constraint and make the",
       "       code more complicated. See the descriptions of U and V."],
     "JOBP"=>
      ["[in]",
       "         JOBP is CHARACTER*1",
       "       Issues the licence to introduce structured perturbations to drown",
       "       denormalized numbers. This licence should be active if the",
       "       denormals are poorly implemented, causing slow computation,",
       "       especially in cases of fast convergence (!). For details see [1,2].",
       "       For the sake of simplicity, this perturbations are included only",
       "       when the full SVD or only the singular values are requested. The",
       "       implementer/user can easily add the perturbation for the cases of",
       "       computing one set of singular vectors.",
       "      = 'P': introduce perturbation",
       "      = 'N': do not perturb"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "        The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The number of columns of the input matrix A. M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "SVA"=>
      ["[out]",
       "         SVA is DOUBLE PRECISION array, dimension (N)",
       "         On exit,",
       "         - For WORK(1)/WORK(2) = ONE: The singular values of A. During the",
       "           computation SVA contains Euclidean column norms of the",
       "           iterated matrices in the array A.",
       "         - For WORK(1) .NE. WORK(2): The singular values of A are",
       "           (WORK(1)/WORK(2)) * SVA(1:N). This factored form is used if",
       "           sigma_max(A) overflows or if small singular values have been",
       "           saved from underflow by scaling the input matrix A.",
       "         - If JOBR='R' then some of the singular values may be returned",
       "           as exact zeros obtained by \"set to zero\" because they are",
       "           below the numerical rank threshold or are denormalized numbers."],
     "U"=>
      ["[out]",
       "         U is DOUBLE PRECISION array, dimension ( LDU, N )",
       "         If JOBU = 'U', then U contains on exit the M-by-N matrix of",
       "                        the left singular vectors.",
       "         If JOBU = 'F', then U contains on exit the M-by-M matrix of",
       "                        the left singular vectors, including an ONB",
       "                        of the orthogonal complement of the Range(A).",
       "         If JOBU = 'W'  .AND. (JOBV.EQ.'V' .AND. JOBT.EQ.'T' .AND. M.EQ.N),",
       "                        then U is used as workspace if the procedure",
       "                        replaces A with A^t. In that case, [V] is computed",
       "                        in U as left singular vectors of A^t and then",
       "                        copied back to the V array. This 'W' option is just",
       "                        a reminder to the caller that in this case U is",
       "                        reserved as workspace of length N*N.",
       "         If JOBU = 'N'  U is not referenced, unless JOBT='T'."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U,  LDU >= 1.",
       "         IF  JOBU = 'U' or 'F' or 'W',  then LDU >= M."],
     "V"=>
      ["[out]",
       "         V is DOUBLE PRECISION array, dimension ( LDV, N )",
       "         If JOBV = 'V', 'J' then V contains on exit the N-by-N matrix of",
       "                        the right singular vectors;",
       "         If JOBV = 'W', AND (JOBU.EQ.'U' AND JOBT.EQ.'T' AND M.EQ.N),",
       "                        then V is used as workspace if the pprocedure",
       "                        replaces A with A^t. In that case, [U] is computed",
       "                        in V as right singular vectors of A^t and then",
       "                        copied back to the U array. This 'W' option is just",
       "                        a reminder to the caller that in this case V is",
       "                        reserved as workspace of length N*N.",
       "         If JOBV = 'N'  V is not referenced, unless JOBT='T'."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V' or 'J' or 'W', then LDV >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension at least LWORK.",
       "         On exit, if N.GT.0 .AND. M.GT.0 (else not referenced),",
       "         WORK(1) = SCALE = WORK(2) / WORK(1) is the scaling factor such",
       "                   that SCALE*SVA(1:N) are the computed singular values",
       "                   of A. (See the description of SVA().)",
       "         WORK(2) = See the description of WORK(1).",
       "         WORK(3) = SCONDA is an estimate for the condition number of",
       "                   column equilibrated A. (If JOBA .EQ. 'E' or 'G')",
       "                   SCONDA is an estimate of DSQRT(||(R^t * R)^(-1)||_1).",
       "                   It is computed using DPOCON. It holds",
       "                   N^(-1/4) * SCONDA <= ||R^(-1)||_2 <= N^(1/4) * SCONDA",
       "                   where R is the triangular factor from the QRF of A.",
       "                   However, if R is truncated and the numerical rank is",
       "                   determined to be strictly smaller than N, SCONDA is",
       "                   returned as -1, thus indicating that the smallest",
       "                   singular values might be lost.",
       "         If full SVD is needed, the following two condition numbers are",
       "         useful for the analysis of the algorithm. They are provied for",
       "         a developer/implementer who is familiar with the details of",
       "         the method.",
       "         WORK(4) = an estimate of the scaled condition number of the",
       "                   triangular factor in the first QR factorization.",
       "         WORK(5) = an estimate of the scaled condition number of the",
       "                   triangular factor in the second QR factorization.",
       "         The following two parameters are computed if JOBT .EQ. 'T'.",
       "         They are provided for a developer/implementer who is familiar",
       "         with the details of the method.",
       "         WORK(6) = the entropy of A^t*A :: this is the Shannon entropy",
       "                   of diag(A^t*A) / Trace(A^t*A) taken as point in the",
       "                   probability simplex.",
       "         WORK(7) = the entropy of A*A^t."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         Length of WORK to confirm proper allocation of work space.",
       "         LWORK depends on the job:",
       "         If only SIGMA is needed ( JOBU.EQ.'N', JOBV.EQ.'N' ) and",
       "           -> .. no scaled condition estimate required (JOBE.EQ.'N'):",
       "              LWORK >= max(2*M+N,4*N+1,7). This is the minimal requirement.",
       "              ->> For optimal performance (blocked code) the optimal value",
       "              is LWORK >= max(2*M+N,3*N+(N+1)*NB,7). Here NB is the optimal",
       "              block size for DGEQP3 and DGEQRF.",
       "              In general, optimal LWORK is computed as",
       "              LWORK >= max(2*M+N,N+LWORK(DGEQP3),N+LWORK(DGEQRF), 7).",
       "           -> .. an estimate of the scaled condition number of A is",
       "              required (JOBA='E', 'G'). In this case, LWORK is the maximum",
       "              of the above and N*N+4*N, i.e. LWORK >= max(2*M+N,N*N+4*N,7).",
       "              ->> For optimal performance (blocked code) the optimal value",
       "              is LWORK >= max(2*M+N,3*N+(N+1)*NB, N*N+4*N, 7).",
       "              In general, the optimal length LWORK is computed as",
       "              LWORK >= max(2*M+N,N+LWORK(DGEQP3),N+LWORK(DGEQRF),",
       "                                                    N+N*N+LWORK(DPOCON),7).",
       "         If SIGMA and the right singular vectors are needed (JOBV.EQ.'V'),",
       "           -> the minimal requirement is LWORK >= max(2*M+N,4*N+1,7).",
       "           -> For optimal performance, LWORK >= max(2*M+N,3*N+(N+1)*NB,7),",
       "              where NB is the optimal block size for DGEQP3, DGEQRF, DGELQF,",
       "              DORMLQ. In general, the optimal length LWORK is computed as",
       "              LWORK >= max(2*M+N,N+LWORK(DGEQP3), N+LWORK(DPOCON),",
       "                      N+LWORK(DGELQF), 2*N+LWORK(DGEQRF), N+LWORK(DORMLQ)).",
       "         If SIGMA and the left singular vectors are needed",
       "           -> the minimal requirement is LWORK >= max(2*M+N,4*N+1,7).",
       "           -> For optimal performance:",
       "              if JOBU.EQ.'U' :: LWORK >= max(2*M+N,3*N+(N+1)*NB,7),",
       "              if JOBU.EQ.'F' :: LWORK >= max(2*M+N,3*N+(N+1)*NB,N+M*NB,7),",
       "              where NB is the optimal block size for DGEQP3, DGEQRF, DORMQR.",
       "              In general, the optimal length LWORK is computed as",
       "              LWORK >= max(2*M+N,N+LWORK(DGEQP3),N+LWORK(DPOCON),",
       "                       2*N+LWORK(DGEQRF), N+LWORK(DORMQR)).",
       "              Here LWORK(DORMQR) equals N*NB (for JOBU.EQ.'U') or",
       "              M*NB (for JOBU.EQ.'F').",
       "         If the full SVD is needed: (JOBU.EQ.'U' or JOBU.EQ.'F') and",
       "           -> if JOBV.EQ.'V'",
       "              the minimal requirement is LWORK >= max(2*M+N,6*N+2*N*N).",
       "           -> if JOBV.EQ.'J' the minimal requirement is",
       "              LWORK >= max(2*M+N, 4*N+N*N,2*N+N*N+6).",
       "           -> For optimal performance, LWORK should be additionally",
       "              larger than N+M*NB, where NB is the optimal block size",
       "              for DORMQR."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension M+3*N.",
       "         On exit,",
       "         IWORK(1) = the numerical rank determined after the initial",
       "                    QR factorization with pivoting. See the descriptions",
       "                    of JOBA and JOBR.",
       "         IWORK(2) = the number of the computed nonzero singular values",
       "         IWORK(3) = if nonzero, a warning message:",
       "                    If IWORK(3).EQ.1 then some of the column norms of A",
       "                    were denormalized floats. The requested high accuracy",
       "                    is not warranted by the data."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          < 0  : if INFO = -i, then the i-th argument had an illegal value.",
       "          = 0 :  successful exit;",
       "          > 0 :  DGEJSV  did not converge in the maximal allowed number",
       "                 of sweeps. The computed values may be inaccurate."]}},
 "sggglm"=>
  {"summary"=>
    ["SGGGLM solves a general Gauss-Markov linear model (GLM) problem:",
     "        minimize || y ||_2   subject to   d = A*x + B*y",
     "            x",
     "where A is an N-by-M matrix, B is an N-by-P matrix, and d is a",
     "given N-vector. It is assumed that M <= N <= M+P, and",
     "           rank(A) = M    and    rank( A B ) = N.",
     "Under these assumptions, the constrained equation is always",
     "consistent, and there is a unique solution x and a minimal 2-norm",
     "solution y, which is obtained using a generalized QR factorization",
     "of the matrices (A, B) given by",
     "   A = Q*(R),   B = Q*T*Z.",
     "         (0)",
     "In particular, if matrix B is square nonsingular, then the problem",
     "GLM is equivalent to the following weighted linear least squares",
     "problem",
     "             minimize || inv(B)*(d-A*x) ||_2",
     "                 x",
     "where inv(B) denotes the inverse of B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrices A and B.  N >= 0."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix A.  0 <= M <= N."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of columns of the matrix B.  P >= N-M."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,M)",
       "         On entry, the N-by-M matrix A.",
       "         On exit, the upper triangular part of the array A contains",
       "         the M-by-M upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,P)",
       "         On entry, the N-by-P matrix B.",
       "         On exit, if N <= P, the upper triangle of the subarray",
       "         B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T;",
       "         if N > P, the elements on and above the (N-P)th subdiagonal",
       "         contain the N-by-P upper trapezoidal matrix T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, D is the left hand side of the GLM equation.",
       "         On exit, D is destroyed."],
     "X"=>["[out]", "         X is REAL array, dimension (M)"],
     "Y"=>
      ["[out]",
       "         Y is REAL array, dimension (P)",
       "         On exit, X and Y are the solutions of the GLM problem."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N+M+P).",
       "         For optimum performance, LWORK >= M+min(N,P)+max(N,P)*NB,",
       "         where NB is an upper bound for the optimal blocksizes for",
       "         SGEQRF, SGERQF, SORMQR and SORMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the upper triangular factor R associated with A in the",
       "               generalized QR factorization of the pair (A, B) is",
       "               singular, so that rank(A) < M; the least squares",
       "               solution could not be computed.",
       "         = 2:  the bottom (N-M) by (N-M) part of the upper trapezoidal",
       "               factor T associated with B in the generalized QR",
       "               factorization of the pair (A, B) is singular, so that",
       "               rank( A B ) < N; the least squares solution could not",
       "               be computed."]}},
 "dsytf2"=>
  {"summary"=>
    ["DSYTF2 computes the factorization of a real symmetric matrix A using",
     "the Bunch-Kaufman diagonal pivoting method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**T is the transpose of U, and D is symmetric and",
     "block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "dgeqr"=>
  {"summary"=>["DGEQR computes a QR factorization of an M-by-N matrix A."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R",
       "         (R is upper triangular if M >= N);",
       "         the elements below the diagonal are used to store part of the ",
       "         data structure to represent Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (MAX(5,TSIZE))",
       "         On exit, if INFO = 0, T(1) returns optimal (or either minimal ",
       "         or optimal, if query is assumed) TSIZE. See TSIZE for details.",
       "         Remaining T contains part of the data structure used to represent Q.",
       "         If one wants to apply or construct Q, then one needs to keep T ",
       "         (in addition to A) and pass it to further subroutines."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         If TSIZE >= 5, the dimension of the array T.",
       "         If TSIZE = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If TSIZE = -1, the routine calculates optimal size of T for the ",
       "         optimum performance and returns this value in T(1).",
       "         If TSIZE = -2, the routine calculates minimal size of T and ",
       "         returns this value in T(1)."],
     "WORK"=>
      ["[out]",
       "         (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhesv_rk"=>
  {"summary"=>
    ["ZHESV_RK computes the solution to a complex system of linear",
     "equations A * X = B, where A is an N-by-N Hermitian matrix",
     "and X and B are N-by-NRHS matrices.",
     "The bounded Bunch-Kaufman (rook) diagonal pivoting method is used",
     "to factor A as",
     "   A = P*U*D*(U**H)*(P**T),  if UPLO = 'U', or",
     "   A = P*L*D*(L**H)*(P**T),  if UPLO = 'L',",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "ZHETRF_RK is called to compute the factorization of a complex",
     "Hermitian matrix.  The factored form of A is then used to solve",
     "the system of equations A * X = B by calling BLAS3 routine ZHETRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, if INFO = 0, diagonal of the block diagonal",
       "         matrix D and factors U or L  as computed by ZHETRF_RK:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         For more info see the description of ZHETRF_RK routine."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On exit, contains the output computed by the factorization",
       "         routine ZHETRF_RK, i.e. the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases.",
       "         For more info see the description of ZHETRF_RK routine."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D,",
       "         as determined by ZHETRF_RK.",
       "         For more info see the description of ZHETRF_RK routine."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension ( MAX(1,LWORK) ).",
       "         Work array used in the factorization stage.",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1. For best performance",
       "         of factorization stage LWORK >= max(1,N*NB), where NB is",
       "         the optimal blocksize for ZHETRF_RK.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array for factorization stage, returns this value as",
       "         the first entry of the WORK array, and no error message",
       "         related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "dsptrf"=>
  {"summary"=>
    ["DSPTRF computes the factorization of a real symmetric matrix A stored",
     "in packed format using the Bunch-Kaufman diagonal pivoting method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L, stored as a packed triangular",
       "         matrix overwriting A (see below for further details)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "ssysvx"=>
  {"summary"=>
    ["SSYSVX uses the diagonal pivoting factorization to compute the",
     "solution to a real system of linear equations A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "zgesc2"=>
  {"summary"=>
    ["ZGESC2 solves a system of linear equations",
     "          A * X = scale* RHS",
     "with a general N-by-N matrix A using the LU factorization with",
     "complete pivoting computed by ZGETC2."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the  LU part of the factorization of the n-by-n",
       "         matrix A computed by ZGETC2:  A = P * L * U * Q"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1, N)."],
     "RHS"=>
      ["[in,out]",
       "         RHS is COMPLEX*16 array, dimension N.",
       "         On entry, the right hand side vector b.",
       "         On exit, the solution vector X."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[in]",
       "         JPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "          On exit, SCALE contains the scale factor. SCALE is chosen",
       "          0 <= SCALE <= 1 to prevent owerflow in the solution."]}},
 "stpttr"=>
  {"summary"=>
    ["STPTTR copies a triangular matrix A from standard packed format (TP)",
     "to standard full format (TR)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular.",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "A"=>
      ["[out]",
       "         A is REAL array, dimension ( LDA, N )",
       "         On exit, the triangular matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sorgql"=>
  {"summary"=>
    ["SORGQL generates an M-by-N real matrix Q with orthonormal columns,",
     "which is defined as the last N columns of a product of K elementary",
     "reflectors of order M",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by SGEQLF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the (n-k+i)-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by SGEQLF in the last k columns of its array",
       "         argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGEQLF."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "cung2l"=>
  {"summary"=>
    ["CUNG2L generates an m by n complex matrix Q with orthonormal columns,",
     "which is defined as the last n columns of a product of k elementary",
     "reflectors of order m",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by CGEQLF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the (n-k+i)-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by CGEQLF in the last k columns of its array",
       "         argument A.",
       "         On exit, the m-by-n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGEQLF."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "dorglq"=>
  {"summary"=>
    ["DORGLQ generates an M-by-N real matrix Q with orthonormal rows,",
     "which is defined as the first M rows of a product of K elementary",
     "reflectors of order N",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by DGELQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the i-th row must contain the vector which defines",
       "         the elementary reflector H(i), for i = 1,2,...,k, as returned",
       "         by DGELQF in the first k rows of its array argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGELQF."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "zgtrfs"=>
  {"summary"=>
    ["ZGTRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is tridiagonal, and provides",
     "error bounds and backward error estimates for the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of A."],
     "D"=>
      ["[in]",
       "         D is COMPLEX*16 array, dimension (N)",
       "         The diagonal elements of A."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) superdiagonal elements of A."],
     "DLF"=>
      ["[in]",
       "         DLF is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A as computed by ZGTTRF."],
     "DF"=>
      ["[in]",
       "         DF is COMPLEX*16 array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DUF"=>
      ["[in]",
       "         DUF is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) elements of the first superdiagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is COMPLEX*16 array, dimension (N-2)",
       "         The (n-2) elements of the second superdiagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by ZGTTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "csytrs2"=>
  {"summary"=>
    ["CSYTRS2 solves a system of linear equations A*X = B with a COMPLEX",
     "symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by CSYTRF and converted by CSYCONV."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CSYTRF.",
       "         Note that A is input / output. This might be counter-intuitive,",
       "         and one may think that A is input only. A is input / output. This",
       "         is because, at the start of the subroutine, we permute A in a",
       "         \"better\" form and then we permute A back to its original form at",
       "         the end."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgtrfs"=>
  {"summary"=>
    ["SGTRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is tridiagonal, and provides",
     "error bounds and backward error estimates for the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is REAL array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of A."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of A."],
     "DU"=>
      ["[in]",
       "         DU is REAL array, dimension (N-1)",
       "         The (n-1) superdiagonal elements of A."],
     "DLF"=>
      ["[in]",
       "         DLF is REAL array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A as computed by SGTTRF."],
     "DF"=>
      ["[in]",
       "         DF is REAL array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DUF"=>
      ["[in]",
       "         DUF is REAL array, dimension (N-1)",
       "         The (n-1) elements of the first superdiagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is REAL array, dimension (N-2)",
       "         The (n-2) elements of the second superdiagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by SGTTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slasr"=>
  {"summary"=>
    ["SLASR applies a sequence of plane rotations to a real matrix A,",
     "from either the left or the right.",
     "When SIDE = 'L', the transformation takes the form",
     "   A := P*A",
     "and when SIDE = 'R', the transformation takes the form",
     "   A := A*P**T",
     "where P is an orthogonal matrix consisting of a sequence of z plane",
     "rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R',",
     "and P**T is the transpose of P.",
     "When DIRECT = 'F' (Forward sequence), then",
     "   P = P(z-1) * ... * P(2) * P(1)",
     "and when DIRECT = 'B' (Backward sequence), then",
     "   P = P(1) * P(2) * ... * P(z-1)",
     "where P(k) is a plane rotation matrix defined by the 2-by-2 rotation",
     "   R(k) = (  c(k)  s(k) )",
     "        = ( -s(k)  c(k) ).",
     "When PIVOT = 'V' (Variable pivot), the rotation is performed",
     "for the plane (k,k+1), i.e., P(k) has the form",
     "   P(k) = (  1                                            )",
     "          (       ...                                     )",
     "          (              1                                )",
     "          (                   c(k)  s(k)                  )",
     "          (                  -s(k)  c(k)                  )",
     "          (                                1              )",
     "          (                                     ...       )",
     "          (                                            1  )",
     "where R(k) appears as a rank-2 modification to the identity matrix in",
     "rows and columns k and k+1.",
     "When PIVOT = 'T' (Top pivot), the rotation is performed for the",
     "plane (1,k+1), so P(k) has the form",
     "   P(k) = (  c(k)                    s(k)                 )",
     "          (         1                                     )",
     "          (              ...                              )",
     "          (                     1                         )",
     "          ( -s(k)                    c(k)                 )",
     "          (                                 1             )",
     "          (                                      ...      )",
     "          (                                             1 )",
     "where R(k) appears in rows and columns 1 and k+1.",
     "Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is",
     "performed for the plane (k,z), giving P(k) the form",
     "   P(k) = ( 1                                             )",
     "          (      ...                                      )",
     "          (             1                                 )",
     "          (                  c(k)                    s(k) )",
     "          (                         1                     )",
     "          (                              ...              )",
     "          (                                     1         )",
     "          (                 -s(k)                    c(k) )",
     "where R(k) appears in rows and columns k and z.  The rotations are",
     "performed without ever forming P(k) explicitly."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         Specifies whether the plane rotation matrix P is applied to",
       "         A on the left or the right.",
       "         = 'L':  Left, compute A := P*A",
       "         = 'R':  Right, compute A:= A*P**T"],
     "PIVOT"=>
      ["[in]",
       "         PIVOT is CHARACTER*1",
       "         Specifies the plane for which P(k) is a plane rotation",
       "         matrix.",
       "         = 'V':  Variable pivot, the plane (k,k+1)",
       "         = 'T':  Top pivot, the plane (1,k+1)",
       "         = 'B':  Bottom pivot, the plane (k,z)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies whether P is a forward or backward sequence of",
       "         plane rotations.",
       "         = 'F':  Forward, P = P(z-1)*...*P(2)*P(1)",
       "         = 'B':  Backward, P = P(1)*P(2)*...*P(z-1)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  If m <= 1, an immediate",
       "         return is effected."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  If n <= 1, an",
       "         immediate return is effected."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension",
       "                 (M-1) if SIDE = 'L'",
       "                 (N-1) if SIDE = 'R'",
       "         The cosines c(k) of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension",
       "                 (M-1) if SIDE = 'L'",
       "                 (N-1) if SIDE = 'R'",
       "         The sines s(k) of the plane rotations.  The 2-by-2 plane",
       "         rotation part of the matrix P(k), R(k), has the form",
       "         R(k) = (  c(k)  s(k) )",
       "                ( -s(k)  c(k) )."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         The M-by-N matrix A.  On exit, A is overwritten by P*A if",
       "         SIDE = 'R' or by A*P**T if SIDE = 'L'."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."]}},
 "zunbdb5"=>
  {"summary"=>[],
   "param"=>
    {"M1"=>
      ["[in]",
       "         M1 is INTEGER",
       "          The dimension of X1 and the number of rows in Q1. 0 <= M1."],
     "M2"=>
      ["[in]",
       "         M2 is INTEGER",
       "          The dimension of X2 and the number of rows in Q2. 0 <= M2."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The number of columns in Q1 and Q2. 0 <= N."],
     "X1"=>
      ["[in,out]",
       "         X1 is COMPLEX*16 array, dimension (M1)",
       "          On entry, the top part of the vector to be orthogonalized.",
       "          On exit, the top part of the projected vector."],
     "INCX1"=>
      ["[in]",
       "         INCX1 is INTEGER",
       "          Increment for entries of X1."],
     "X2"=>
      ["[in,out]",
       "         X2 is COMPLEX*16 array, dimension (M2)",
       "          On entry, the bottom part of the vector to be",
       "          orthogonalized. On exit, the bottom part of the projected",
       "          vector."],
     "INCX2"=>
      ["[in]",
       "         INCX2 is INTEGER",
       "          Increment for entries of X2."],
     "Q1"=>
      ["[in]",
       "         Q1 is COMPLEX*16 array, dimension (LDQ1, N)",
       "          The top part of the orthonormal basis matrix."],
     "LDQ1"=>
      ["[in]",
       "         LDQ1 is INTEGER",
       "          The leading dimension of Q1. LDQ1 >= M1."],
     "Q2"=>
      ["[in]",
       "         Q2 is COMPLEX*16 array, dimension (LDQ2, N)",
       "          The bottom part of the orthonormal basis matrix."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "          The leading dimension of Q2. LDQ2 >= M2."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zlagtm"=>
  {"summary"=>
    ["ZLAGTM performs a matrix-vector product of the form",
     "   B := alpha * A * X + beta * B",
     "where A is a tridiagonal matrix of order N, B and X are N by NRHS",
     "matrices, and alpha and beta are real scalars, each of which may be",
     "0., 1., or -1."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  No transpose, B := alpha * A * X + beta * B",
       "         = 'T':  Transpose,    B := alpha * A**T * X + beta * B",
       "         = 'C':  Conjugate transpose, B := alpha * A**H * X + beta * B"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices X and B."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "         The scalar alpha.  ALPHA must be 0., 1., or -1.; otherwise,",
       "         it is assumed to be 0."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) sub-diagonal elements of T."],
     "D"=>
      ["[in]",
       "         D is COMPLEX*16 array, dimension (N)",
       "         The diagonal elements of T."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) super-diagonal elements of T."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         The N by NRHS matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(N,1)."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION",
       "         The scalar beta.  BETA must be 0., 1., or -1.; otherwise,",
       "         it is assumed to be 1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N by NRHS matrix B.",
       "         On exit, B is overwritten by the matrix expression",
       "         B := alpha * A * X + beta * B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(N,1)."]}},
 "sormbr"=>
  {"summary"=>
    ["If VECT = 'Q', SORMBR overwrites the general real M-by-N matrix C",
     "with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "If VECT = 'P', SORMBR overwrites the general real M-by-N matrix C",
     "with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      P * C          C * P",
     "TRANS = 'T':      P**T * C       C * P**T",
     "Here Q and P**T are the orthogonal matrices determined by SGEBRD when",
     "reducing a real matrix A to bidiagonal form: A = Q * B * P**T. Q and",
     "P**T are defined as products of elementary reflectors H(i) and G(i)",
     "respectively.",
     "Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the",
     "order of the orthogonal matrix Q or P**T that is applied.",
     "If VECT = 'Q', A is assumed to have been an NQ-by-K matrix:",
     "if nq >= k, Q = H(1) H(2) . . . H(k);",
     "if nq < k, Q = H(1) H(2) . . . H(nq-1).",
     "If VECT = 'P', A is assumed to have been a K-by-NQ matrix:",
     "if k < nq, P = G(1) G(2) . . . G(k);",
     "if k >= nq, P = G(1) G(2) . . . G(nq-1)."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'Q': apply Q or Q**T;",
       "         = 'P': apply P or P**T."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q, Q**T, P or P**T from the Left;",
       "         = 'R': apply Q, Q**T, P or P**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q  or P;",
       "         = 'T':  Transpose, apply Q**T or P**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         If VECT = 'Q', the number of columns in the original",
       "         matrix reduced by SGEBRD.",
       "         If VECT = 'P', the number of rows in the original",
       "         matrix reduced by SGEBRD.",
       "         K >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension",
       "                               (LDA,min(nq,K)) if VECT = 'Q'",
       "                               (LDA,nq)        if VECT = 'P'",
       "         The vectors which define the elementary reflectors H(i) and",
       "         G(i), whose products determine the matrices Q and P, as",
       "         returned by SGEBRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If VECT = 'Q', LDA >= max(1,nq);",
       "         if VECT = 'P', LDA >= max(1,min(nq,K))."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (min(nq,K))",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i) or G(i) which determines Q or P, as returned",
       "         by SGEBRD in the array argument TAUQ or TAUP."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q",
       "         or P*C or P**T*C or C*P or C*P**T."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For optimum performance LWORK >= N*NB if SIDE = 'L', and",
       "         LWORK >= M*NB if SIDE = 'R', where NB is the optimal",
       "         blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zposv"=>
  {"summary"=>
    ["ZPOSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite matrix and X and B",
     "are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**H* U,  if UPLO = 'U', or",
     "   A = L * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and  L is a lower triangular",
     "matrix.  The factored form of A is then used to solve the system of",
     "equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**H *U or A = L*L**H."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "dtrevc3"=>
  {"summary"=>
    ["DTREVC3 computes some or all of the right and/or left eigenvectors of",
     "a real upper quasi-triangular matrix T.",
     "Matrices of this type are produced by the Schur factorization of",
     "a real general matrix:  A = Q*T*Q**T, as computed by DHSEQR.",
     "The right eigenvector x and the left eigenvector y of T corresponding",
     "to an eigenvalue w are defined by:",
     "   T*x = w*x,     (y**H)*T = w*(y**H)",
     "where y**H denotes the conjugate transpose of y.",
     "The eigenvalues are not input to this routine, but are read directly",
     "from the diagonal blocks of T.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an",
     "input matrix. If Q is the orthogonal factor that reduces a matrix",
     "A to Schur form T, then Q*X and Q*Y are the matrices of right and",
     "left eigenvectors of A.",
     "This uses a Level 3 BLAS version of the back transformation."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  compute right eigenvectors only;",
       "         = 'L':  compute left eigenvectors only;",
       "         = 'B':  compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A':  compute all right and/or left eigenvectors;",
       "         = 'B':  compute all right and/or left eigenvectors,",
       "                 backtransformed by the matrices in VR and/or VL;",
       "         = 'S':  compute selected right and/or left eigenvectors,",
       "                 as indicated by the logical array SELECT."],
     "SELECT"=>
      ["[in,out]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenvectors to be",
       "         computed.",
       "         If w(j) is a real eigenvalue, the corresponding real",
       "         eigenvector is computed if SELECT(j) is .TRUE..",
       "         If w(j) and w(j+1) are the real and imaginary parts of a",
       "         complex eigenvalue, the corresponding complex eigenvector is",
       "         computed if either SELECT(j) or SELECT(j+1) is .TRUE., and",
       "         on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is set to",
       "         .FALSE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         The upper quasi-triangular matrix T in Schur canonical form."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is DOUBLE PRECISION array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the orthogonal matrix Q",
       "         of Schur vectors returned by DHSEQR).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VL, in the same order as their",
       "                          eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part, and the second the imaginary part.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= 1, and if SIDE = 'L' or 'B', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is DOUBLE PRECISION array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Q (usually the orthogonal matrix Q",
       "         of Schur vectors returned by DHSEQR).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*X;",
       "         if HOWMNY = 'S', the right eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VR, in the same order as their",
       "                          eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part and the second the imaginary part.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= 1, and if SIDE = 'R' or 'B', LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.",
       "         If HOWMNY = 'A' or 'B', M is set to N.",
       "         Each selected real eigenvector occupies one column and each",
       "         selected complex eigenvector occupies two columns."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of array WORK. LWORK >= max(1,3*N).",
       "         For optimum performance, LWORK >= N + 2*N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slas2"=>
  {"summary"=>
    ["SLAS2  computes the singular values of the 2-by-2 matrix",
     "   [  F   G  ]",
     "   [  0   H  ].",
     "On return, SSMIN is the smaller singular value and SSMAX is the",
     "larger singular value."],
   "param"=>
    {"F"=>
      ["[in]",
       "         F is REAL",
       "         The (1,1) element of the 2-by-2 matrix."],
     "G"=>
      ["[in]",
       "         G is REAL",
       "         The (1,2) element of the 2-by-2 matrix."],
     "H"=>
      ["[in]",
       "         H is REAL",
       "         The (2,2) element of the 2-by-2 matrix."],
     "SSMIN"=>
      ["[out]",
       "         SSMIN is REAL",
       "         The smaller singular value."],
     "SSMAX"=>
      ["[out]",
       "         SSMAX is REAL",
       "         The larger singular value."]}},
 "zpbsvx"=>
  {"summary"=>
    ["ZPBSVX uses the Cholesky factorization A = U**H*U or A = L*L**H to",
     "compute the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite band matrix and X",
     "and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "zpotrf2"=>
  {"summary"=>
    ["ZPOTRF2 computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A using the recursive algorithm.",
     "The factorization has the form",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the recursive version of the algorithm. It divides",
     "the matrix into four submatrices:",
     "       [  A11 | A12  ]  where A11 is n1 by n1 and A22 is n2 by n2",
     "   A = [ -----|----- ]  with n1 = n/2",
     "       [  A21 | A22  ]       n2 = n-n1",
     "The subroutine calls itself to factor A11. Update and scale A21",
     "or A12, update A22 then call itself to factor A22."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**H*U or A = L*L**H."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "chpev"=>
  {"summary"=>
    ["CHPEV computes all the eigenvalues and, optionally, eigenvectors of a",
     "complex Hermitian matrix in packed storage."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX array, dimension (max(1, 2*N-1))"],
     "RWORK"=>
      ["[out]", "         RWORK is REAL array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "ctprfb"=>
  {"summary"=>
    ["CTPRFB applies a complex \"triangular-pentagonal\" block reflector H or its",
     "conjugate transpose H**H to a complex matrix C, which is composed of two",
     "blocks A and B, either from the left or right."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H**H from the Left",
       "         = 'R': apply H or H**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'C': apply H**H (Conjugate transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columns",
       "         = 'R': Rows"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B.",
       "         N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T, i.e. the number of elementary",
       "         reflectors whose product defines the block reflector.",
       "         K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension",
       "                               (LDV,K) if STOREV = 'C'",
       "                               (LDV,M) if STOREV = 'R' and SIDE = 'L'",
       "                               (LDV,N) if STOREV = 'R' and SIDE = 'R'",
       "         The pentagonal matrix V, which contains the elementary reflectors",
       "         H(1), H(2), ..., H(K).  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);",
       "         if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);",
       "         if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension (LDT,K)",
       "         The triangular K-by-K matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.",
       "         LDT >= K."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension",
       "         (LDA,N) if SIDE = 'L' or (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         H*C or H**H*C or C*H or C*H**H.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         H*C or H**H*C or C*H or C*H**H.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension",
       "         (LDWORK,N) if SIDE = 'L',",
       "         (LDWORK,K) if SIDE = 'R'."],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= K;",
       "         if SIDE = 'R', LDWORK >= M."]}},
 "cgetrs"=>
  {"summary"=>
    ["CGETRS solves a system of linear equations",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B",
     "with a general N-by-N matrix A using the LU factorization computed",
     "by CGETRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by CGETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from CGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clatdf"=>
  {"summary"=>
    ["CLATDF computes the contribution to the reciprocal Dif-estimate",
     "by solving for x in Z * x = b, where b is chosen such that the norm",
     "of x is as large as possible. It is assumed that LU decomposition",
     "of Z has been computed by CGETC2. On entry RHS = f holds the",
     "contribution from earlier solved sub-systems, and on return RHS = x.",
     "The factorization of Z returned by CGETC2 has the form",
     "Z = P * L * U * Q, where P and Q are permutation matrices. L is lower",
     "triangular with unit diagonal elements and U is upper triangular."],
   "param"=>
    {"IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         IJOB = 2: First compute an approximative null-vector e",
       "             of Z using CGECON, e is normalized and solve for",
       "             Zx = +-e - f with the sign giving the greater value of",
       "             2-norm(x).  About 5 times as expensive as Default.",
       "         IJOB .ne. 2: Local look ahead strategy where",
       "             all entries of the r.h.s. b is chosen as either +1 or",
       "             -1.  Default."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Z."],
     "Z"=>
      ["[in]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         On entry, the LU part of the factorization of the n-by-n",
       "         matrix Z computed by CGETC2:  Z = P * L * U * Q"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDA >= max(1, N)."],
     "RHS"=>
      ["[in,out]",
       "         RHS is COMPLEX array, dimension (N).",
       "         On entry, RHS contains contributions from other subsystems.",
       "         On exit, RHS contains the solution of the subsystem with",
       "         entries according to the value of IJOB (see above)."],
     "RDSUM"=>
      ["[in,out]",
       "         RDSUM is REAL",
       "         On entry, the sum of squares of computed contributions to",
       "         the Dif-estimate under computation by CTGSYL, where the",
       "         scaling factor RDSCAL (see below) has been factored out.",
       "         On exit, the corresponding sum of squares updated with the",
       "         contributions from the current sub-system.",
       "         If TRANS = 'T' RDSUM is not touched.",
       "         NOTE: RDSUM only makes sense when CTGSY2 is called by CTGSYL."],
     "RDSCAL"=>
      ["[in,out]",
       "         RDSCAL is REAL",
       "         On entry, scaling factor used to prevent overflow in RDSUM.",
       "         On exit, RDSCAL is updated w.r.t. the current contributions",
       "         in RDSUM.",
       "         If TRANS = 'T', RDSCAL is not touched.",
       "         NOTE: RDSCAL only makes sense when CTGSY2 is called by",
       "         CTGSYL."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[in]",
       "         JPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."]}},
 "dtrcon"=>
  {"summary"=>
    ["DTRCON estimates the reciprocal of the condition number of a",
     "triangular matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgbtrf"=>
  {"summary"=>
    ["CGBTRF computes an LU factorization of a complex m-by-n band matrix A",
     "using partial pivoting with row interchanges.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(kl+ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = +i, U(i,i) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "stgsy2"=>
  {"summary"=>
    ["STGSY2 solves the generalized Sylvester equation:",
     "            A * R - L * B = scale * C                (1)",
     "            D * R - L * E = scale * F,",
     "using Level 1 and 2 BLAS. where R and L are unknown M-by-N matrices,",
     "(A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M,",
     "N-by-N and M-by-N, respectively, with real entries. (A, D) and (B, E)",
     "must be in generalized Schur canonical form, i.e. A, B are upper",
     "quasi triangular and D, E are upper triangular. The solution (R, L)",
     "overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor",
     "chosen to avoid overflow.",
     "In matrix notation solving equation (1) corresponds to solve",
     "Z*x = scale*b, where Z is defined as",
     "       Z = [ kron(In, A)  -kron(B**T, Im) ]             (2)",
     "           [ kron(In, D)  -kron(E**T, Im) ],",
     "Ik is the identity matrix of size k and X**T is the transpose of X.",
     "kron(X, Y) is the Kronecker product between the matrices X and Y.",
     "In the process of solving (1), we solve a number of such systems",
     "where Dim(In), Dim(In) = 1 or 2.",
     "If TRANS = 'T', solve the transposed system Z**T*y = scale*b for y,",
     "which is equivalent to solve for R and L in",
     "            A**T * R  + D**T * L   = scale * C           (3)",
     "            R  * B**T + L  * E**T  = scale * -F",
     "This case is used to compute an estimate of Dif[(A, D), (B, E)] =",
     "sigma_min(Z) using reverse communicaton with SLACON.",
     "STGSY2 also (IJOB >= 1) contributes to the computation in STGSYL",
     "of an upper bound on the separation between to matrix pairs. Then",
     "the input (A, D), (B, E) are sub-pencils of the matrix pair in",
     "STGSYL. See STGSYL for details."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N', solve the generalized Sylvester equation (1).",
       "         = 'T': solve the 'transposed' system (3)."],
     "IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies what kind of functionality to be performed.",
       "         = 0: solve (1) only.",
       "         = 1: A contribution from this subsystem to a Frobenius",
       "              norm-based estimate of the separation between two matrix",
       "              pairs is computed. (look ahead strategy is used).",
       "         = 2: A contribution from this subsystem to a Frobenius",
       "              norm-based estimate of the separation between two matrix",
       "              pairs is computed. (SGECON on sub-systems is used.)",
       "         Not referenced if TRANS = 'T'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         On entry, M specifies the order of A and D, and the row",
       "         dimension of C, F, R and L."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         On entry, N specifies the order of B and E, and the column",
       "         dimension of C, F, R and L."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA, M)",
       "         On entry, A contains an upper quasi triangular matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the matrix A. LDA >= max(1, M)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, B contains an upper quasi triangular matrix."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the matrix B. LDB >= max(1, N)."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC, N)",
       "         On entry, C contains the right-hand-side of the first matrix",
       "         equation in (1).",
       "         On exit, if IJOB = 0, C has been overwritten by the",
       "         solution R."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the matrix C. LDC >= max(1, M)."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (LDD, M)",
       "         On entry, D contains an upper triangular matrix."],
     "LDD"=>
      ["[in]",
       "         LDD is INTEGER",
       "         The leading dimension of the matrix D. LDD >= max(1, M)."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (LDE, N)",
       "         On entry, E contains an upper triangular matrix."],
     "LDE"=>
      ["[in]",
       "         LDE is INTEGER",
       "         The leading dimension of the matrix E. LDE >= max(1, N)."],
     "F"=>
      ["[in,out]",
       "         F is REAL array, dimension (LDF, N)",
       "         On entry, F contains the right-hand-side of the second matrix",
       "         equation in (1).",
       "         On exit, if IJOB = 0, F has been overwritten by the",
       "         solution L."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the matrix F. LDF >= max(1, M)."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         On exit, 0 <= SCALE <= 1. If 0 < SCALE < 1, the solutions",
       "         R and L (C and F on entry) will hold the solutions to a",
       "         slightly perturbed system but the input matrices A, B, D and",
       "         E have not been changed. If SCALE = 0, R and L will hold the",
       "         solutions to the homogeneous system with C = F = 0. Normally,",
       "         SCALE = 1."],
     "RDSUM"=>
      ["[in,out]",
       "         RDSUM is REAL",
       "         On entry, the sum of squares of computed contributions to",
       "         the Dif-estimate under computation by STGSYL, where the",
       "         scaling factor RDSCAL (see below) has been factored out.",
       "         On exit, the corresponding sum of squares updated with the",
       "         contributions from the current sub-system.",
       "         If TRANS = 'T' RDSUM is not touched.",
       "         NOTE: RDSUM only makes sense when STGSY2 is called by STGSYL."],
     "RDSCAL"=>
      ["[in,out]",
       "         RDSCAL is REAL",
       "         On entry, scaling factor used to prevent overflow in RDSUM.",
       "         On exit, RDSCAL is updated w.r.t. the current contributions",
       "         in RDSUM.",
       "         If TRANS = 'T', RDSCAL is not touched.",
       "         NOTE: RDSCAL only makes sense when STGSY2 is called by",
       "               STGSYL."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (M+N+2)"],
     "PQ"=>
      ["[out]",
       "         PQ is INTEGER",
       "         On exit, the number of subsystems (of size 2-by-2, 4-by-4 and",
       "         8-by-8) solved by this routine."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, if INFO is set to",
       "           =0: Successful exit",
       "           <0: If INFO = -i, the i-th argument had an illegal value.",
       "           >0: The matrix pairs (A, D) and (B, E) have common or very",
       "               close eigenvalues."]}},
 "zgeqr2"=>
  {"summary"=>
    ["ZGEQR2 computes a QR factorization of a complex m by n matrix A:",
     "A = Q * R."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(m,n) by n upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n); the elements below the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zla_porpvgrw"=>
  {"summary"=>
    ["ZLA_PORPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A. NCOLS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by ZPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "WORK"=>
      ["[in]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"]}},
 "ztplqt2"=>
  {"summary"=>
    ["ZTPLQT2 computes a LQ a factorization of a complex \"triangular-pentagonal\"",
     "matrix C, which is composed of a triangular block A and pentagonal block B,",
     "using the compact WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of",
       "         the triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the lower trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the lower triangular M-by-M matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the lower triangular matrix L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first N-L columns",
       "         are rectangular, and the last L columns are lower trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,M)",
       "         The N-by-N upper triangular factor T of the block reflector.",
       "         See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "slasdq"=>
  {"summary"=>
    ["SLASDQ computes the singular value decomposition (SVD) of a real",
     "(upper or lower) bidiagonal matrix with diagonal D and offdiagonal",
     "E, accumulating the transformations if desired. Letting B denote",
     "the input bidiagonal matrix, the algorithm computes orthogonal",
     "matrices Q and P such that B = Q * S * P**T (P**T denotes the transpose",
     "of P). The singular values S are overwritten on D.",
     "The input matrix U  is changed to U  * Q  if desired.",
     "The input matrix VT is changed to P**T * VT if desired.",
     "The input matrix C  is changed to Q**T * C  if desired.",
     "See \"Computing  Small Singular Values of Bidiagonal Matrices With",
     "Guaranteed High Relative Accuracy,\" by J. Demmel and W. Kahan,",
     "LAPACK Working Note #3, for a detailed description of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "       On entry, UPLO specifies whether the input bidiagonal matrix",
       "       is upper or lower bidiagonal, and whether it is square are",
       "       not.",
       "          UPLO = 'U' or 'u'   B is upper bidiagonal.",
       "          UPLO = 'L' or 'l'   B is lower bidiagonal."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "       = 0: then the input matrix is N-by-N.",
       "       = 1: then the input matrix is N-by-(N+1) if UPLU = 'U' and",
       "            (N+1)-by-N if UPLU = 'L'.",
       "       The bidiagonal matrix has",
       "       N = NL + NR + 1 rows and",
       "       M = N + SQRE >= N columns."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "       On entry, N specifies the number of rows and columns",
       "       in the matrix. N must be at least 0."],
     "NCVT"=>
      ["[in]",
       "         NCVT is INTEGER",
       "       On entry, NCVT specifies the number of columns of",
       "       the matrix VT. NCVT must be at least 0."],
     "NRU"=>
      ["[in]",
       "         NRU is INTEGER",
       "       On entry, NRU specifies the number of rows of",
       "       the matrix U. NRU must be at least 0."],
     "NCC"=>
      ["[in]",
       "         NCC is INTEGER",
       "       On entry, NCC specifies the number of columns of",
       "       the matrix C. NCC must be at least 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "       On entry, D contains the diagonal entries of the",
       "       bidiagonal matrix whose SVD is desired. On normal exit,",
       "       D contains the singular values in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array.",
       "       dimension is (N-1) if SQRE = 0 and N if SQRE = 1.",
       "       On entry, the entries of E contain the offdiagonal entries",
       "       of the bidiagonal matrix whose SVD is desired. On normal",
       "       exit, E will contain 0. If the algorithm does not converge,",
       "       D and E will contain the diagonal and superdiagonal entries",
       "       of a bidiagonal matrix orthogonally equivalent to the one",
       "       given as input."],
     "VT"=>
      ["[in,out]",
       "         VT is REAL array, dimension (LDVT, NCVT)",
       "       On entry, contains a matrix which on exit has been",
       "       premultiplied by P**T, dimension N-by-NCVT if SQRE = 0",
       "       and (N+1)-by-NCVT if SQRE = 1 (not referenced if NCVT=0)."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "       On entry, LDVT specifies the leading dimension of VT as",
       "       declared in the calling (sub) program. LDVT must be at",
       "       least 1. If NCVT is nonzero LDVT must also be at least N."],
     "U"=>
      ["[in,out]",
       "         U is REAL array, dimension (LDU, N)",
       "       On entry, contains a  matrix which on exit has been",
       "       postmultiplied by Q, dimension NRU-by-N if SQRE = 0",
       "       and NRU-by-(N+1) if SQRE = 1 (not referenced if NRU=0)."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "       On entry, LDU  specifies the leading dimension of U as",
       "       declared in the calling (sub) program. LDU must be at",
       "       least max( 1, NRU ) ."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC, NCC)",
       "       On entry, contains an N-by-NCC matrix which on exit",
       "       has been premultiplied by Q**T  dimension N-by-NCC if SQRE = 0",
       "       and (N+1)-by-NCC if SQRE = 1 (not referenced if NCC=0)."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "       On entry, LDC  specifies the leading dimension of C as",
       "       declared in the calling (sub) program. LDC must be at",
       "       least 1. If NCC is nonzero, LDC must also be at least N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (4*N)",
       "       Workspace. Only referenced if one of NCVT, NRU, or NCC is",
       "       nonzero, and if N is at least 2."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "       On exit, a value of 0 indicates a successful exit.",
       "       If INFO < 0, argument number -INFO is illegal.",
       "       If INFO > 0, the algorithm did not converge, and INFO",
       "       specifies how many superdiagonals did not converge."]}},
 "claqr2"=>
  {"summary"=>
    ["   CLAQR2 is identical to CLAQR3 except that it avoids",
     "   recursion by calling CLAHQR instead of CLAQR4.",
     "   Aggressive early deflation:",
     "   This subroutine accepts as input an upper Hessenberg matrix",
     "   H and performs an unitary similarity transformation",
     "   designed to detect and deflate fully converged eigenvalues from",
     "   a trailing principal submatrix.  On output H has been over-",
     "   written by a new Hessenberg matrix that is a perturbation of",
     "   an unitary similarity transformation of H.  It is to be",
     "   hoped that the final version of H has many zero subdiagonal",
     "   entries."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         If .TRUE., then the Hessenberg matrix H is fully updated",
       "         so that the triangular Schur factor may be",
       "         computed (in cooperation with the calling subroutine).",
       "         If .FALSE., then only enough of H is updated to preserve",
       "         the eigenvalues."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         If .TRUE., then the unitary matrix Z is updated so",
       "         so that the unitary Schur factor may be computed",
       "         (in cooperation with the calling subroutine).",
       "         If .FALSE., then Z is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H and (if WANTZ is .TRUE.) the",
       "         order of the unitary matrix Z."],
     "KTOP"=>
      ["[in]",
       "         KTOP is INTEGER",
       "         It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.",
       "         KBOT and KTOP together determine an isolated block",
       "         along the diagonal of the Hessenberg matrix."],
     "KBOT"=>
      ["[in]",
       "         KBOT is INTEGER",
       "         It is assumed without a check that either",
       "         KBOT = N or H(KBOT+1,KBOT)=0.  KBOT and KTOP together",
       "         determine an isolated block along the diagonal of the",
       "         Hessenberg matrix."],
     "NW"=>
      ["[in]",
       "         NW is INTEGER",
       "         Deflation window size.  1 .LE. NW .LE. (KBOT-KTOP+1)."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX array, dimension (LDH,N)",
       "         On input the initial N-by-N section of H stores the",
       "         Hessenberg matrix undergoing aggressive early deflation.",
       "         On output H has been transformed by a unitary",
       "         similarity transformation, perturbed, and the returned",
       "         to Hessenberg form that (it is to be hoped) has some",
       "         zero subdiagonal entries."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "         Leading dimension of H just as declared in the calling",
       "         subroutine.  N .LE. LDH"],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ,N)",
       "         IF WANTZ is .TRUE., then on output, the unitary",
       "         similarity transformation mentioned above has been",
       "         accumulated into Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "         If WANTZ is .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer",
       "         The leading dimension of Z just as declared in the",
       "         calling subroutine.  1 .LE. LDZ."],
     "NS"=>
      ["[out]",
       "         NS is integer",
       "         The number of unconverged (ie approximate) eigenvalues",
       "         returned in SR and SI that may be used as shifts by the",
       "         calling subroutine."],
     "ND"=>
      ["[out]",
       "         ND is integer",
       "         The number of converged eigenvalues uncovered by this",
       "         subroutine."],
     "SH"=>
      ["[out]",
       "         SH is COMPLEX array, dimension KBOT",
       "         On output, approximate eigenvalues that may",
       "         be used for shifts are stored in SH(KBOT-ND-NS+1)",
       "         through SR(KBOT-ND).  Converged eigenvalues are",
       "         stored in SH(KBOT-ND+1) through SH(KBOT)."],
     "V"=>
      ["[out]",
       "         V is COMPLEX array, dimension (LDV,NW)",
       "         An NW-by-NW work array."],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "         The leading dimension of V just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "         The number of columns of T.  NH.GE.NW."],
     "T"=>["[out]", "         T is COMPLEX array, dimension (LDT,NW)"],
     "LDT"=>
      ["[in]",
       "         LDT is integer",
       "         The leading dimension of T just as declared in the",
       "         calling subroutine.  NW .LE. LDT"],
     "NV"=>
      ["[in]",
       "         NV is integer",
       "         The number of rows of work array WV available for",
       "         workspace.  NV.GE.NW."],
     "WV"=>["[out]", "         WV is COMPLEX array, dimension (LDWV,NW)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer",
       "         The leading dimension of W just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension LWORK.",
       "         On exit, WORK(1) is set to an estimate of the optimal value",
       "         of LWORK for the given values of N, NW, KTOP and KBOT."],
     "LWORK"=>
      ["[in]",
       "         LWORK is integer",
       "         The dimension of the work array WORK.  LWORK = 2*NW",
       "         suffices, but greater efficiency may result from larger",
       "         values of LWORK.",
       "         If LWORK = -1, then a workspace query is assumed; CLAQR2",
       "         only estimates the optimal workspace size for the given",
       "         values of N, NW, KTOP and KBOT.  The estimate is returned",
       "         in WORK(1).  No error message related to LWORK is issued",
       "         by XERBLA.  Neither H nor Z are accessed."]}},
 "ssyev_2stage"=>
  {"summary"=>
    ["SSYEV_2STAGE computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric matrix A using the 2stage technique for",
     "the reduction to tridiagonal."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension LWORK",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + 2*N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + 2*N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "sgbsv"=>
  {"summary"=>
    ["SGBSV computes the solution to a real system of linear equations",
     "A * X = B, where A is a band matrix of order N with KL subdiagonals",
     "and KU superdiagonals, and X and B are N-by-NRHS matrices.",
     "The LU decomposition with partial pivoting and row interchanges is",
     "used to factor A as A = L * U, where L is a product of permutation",
     "and unit lower triangular matrices with KL subdiagonals, and U is",
     "upper triangular with KL+KU superdiagonals.  The factored form of A",
     "is then used to solve the system of equations A * X = B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(KL+KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+KL)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices that define the permutation matrix P;",
       "         row i of the matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero.  The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and the solution has not been computed."]}},
 "ctzrzf"=>
  {"summary"=>
    ["CTZRZF reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A",
     "to upper triangular form by means of unitary transformations.",
     "The upper trapezoidal matrix A is factored as",
     "   A = ( R  0 ) * Z,",
     "where Z is an N-by-N unitary matrix and R is an M-by-M upper",
     "triangular matrix."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= M."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the leading M-by-N upper trapezoidal part of the",
       "         array A must contain the matrix to be factorized.",
       "         On exit, the leading M-by-M upper triangular part of A",
       "         contains the upper triangular matrix R, and elements M+1 to",
       "         N of the first M rows of A, with the array TAU, represent the",
       "         unitary matrix Z as a product of M elementary reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (M)",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "stgsen"=>
  {"summary"=>
    ["STGSEN reorders the generalized real Schur decomposition of a real",
     "matrix pair (A, B) (in terms of an orthonormal equivalence trans-",
     "formation Q**T * (A, B) * Z), so that a selected cluster of eigenvalues",
     "appears in the leading diagonal blocks of the upper quasi-triangular",
     "matrix A and the upper triangular B. The leading columns of Q and",
     "Z form orthonormal bases of the corresponding left and right eigen-",
     "spaces (deflating subspaces). (A, B) must be in generalized real",
     "Schur canonical form (as returned by SGGES), i.e. A is block upper",
     "triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper",
     "triangular.",
     "STGSEN also computes the generalized eigenvalues",
     "            w(j) = (ALPHAR(j) + i*ALPHAI(j))/BETA(j)",
     "of the reordered matrix pair (A, B).",
     "Optionally, STGSEN computes the estimates of reciprocal condition",
     "numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11),",
     "(A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s)",
     "between the matrix pairs (A11, B11) and (A22,B22) that correspond to",
     "the selected cluster and the eigenvalues outside the cluster, resp.,",
     "and norms of \"projections\" onto left and right eigenspaces w.r.t.",
     "the selected cluster in the (1,1)-block."],
   "param"=>
    {"IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies whether condition numbers are required for the",
       "         cluster of eigenvalues (PL and PR) or the deflating subspaces",
       "         (Difu and Difl):",
       "          =0: Only reorder w.r.t. SELECT. No extras.",
       "          =1: Reciprocal of norms of \"projections\" onto left and right",
       "              eigenspaces w.r.t. the selected cluster (PL and PR).",
       "          =2: Upper bounds on Difu and Difl. F-norm-based estimate",
       "              (DIF(1:2)).",
       "          =3: Estimate of Difu and Difl. 1-norm-based estimate",
       "              (DIF(1:2)).",
       "              About 5 times as expensive as IJOB = 2.",
       "          =4: Compute PL, PR and DIF (i.e. 0, 1 and 2 above): Economic",
       "              version to get it all.",
       "          =5: Compute PL, PR and DIF (i.e. 0, 1 and 3 above)"],
     "WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         SELECT specifies the eigenvalues in the selected cluster.",
       "         To select a real eigenvalue w(j), SELECT(j) must be set to",
       "         .TRUE.. To select a complex conjugate pair of eigenvalues",
       "         w(j) and w(j+1), corresponding to a 2-by-2 diagonal block,",
       "         either SELECT(j) or SELECT(j+1) or both must be set to",
       "         .TRUE.; a complex conjugate pair of eigenvalues must be",
       "         either both included in the cluster or both excluded."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension(LDA,N)",
       "         On entry, the upper quasi-triangular matrix A, with (A, B) in",
       "         generalized real Schur canonical form.",
       "         On exit, A is overwritten by the reordered matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension(LDB,N)",
       "         On entry, the upper triangular matrix B, with (A, B) in",
       "         generalized real Schur canonical form.",
       "         On exit, B is overwritten by the reordered matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "ALPHAR"=>["[out]", "         ALPHAR is REAL array, dimension (N)"],
     "ALPHAI"=>["[out]", "         ALPHAI is REAL array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  ALPHAR(j) + ALPHAI(j)*i",
       "         and BETA(j),j=1,...,N  are the diagonals of the complex Schur",
       "         form (S,T) that would result if the 2-by-2 diagonal blocks of",
       "         the real generalized Schur form of (A,B) were further reduced",
       "         to triangular form using complex unitary transformations.",
       "         If ALPHAI(j) is zero, then the j-th eigenvalue is real; if",
       "         positive, then the j-th and (j+1)-st eigenvalues are a",
       "         complex conjugate pair, with ALPHAI(j+1) negative."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "         On entry, if WANTQ = .TRUE., Q is an N-by-N matrix.",
       "         On exit, Q has been postmultiplied by the left orthogonal",
       "         transformation matrix which reorder (A, B); The leading M",
       "         columns of Q form orthonormal bases for the specified pair of",
       "         left eigenspaces (deflating subspaces).",
       "         If WANTQ = .FALSE., Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= 1;",
       "         and if WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ,N)",
       "         On entry, if WANTZ = .TRUE., Z is an N-by-N matrix.",
       "         On exit, Z has been postmultiplied by the left orthogonal",
       "         transformation matrix which reorder (A, B); The leading M",
       "         columns of Z form orthonormal bases for the specified pair of",
       "         left eigenspaces (deflating subspaces).",
       "         If WANTZ = .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1;",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The dimension of the specified pair of left and right eigen-",
       "         spaces (deflating subspaces). 0 <= M <= N."],
     "PL"=>["[out]", "         PL is REAL"],
     "PR"=>
      ["[out]",
       "         PR is REAL",
       "         If IJOB = 1, 4 or 5, PL, PR are lower bounds on the",
       "         reciprocal of the norm of \"projections\" onto left and right",
       "         eigenspaces with respect to the selected cluster.",
       "         0 < PL, PR <= 1.",
       "         If M = 0 or M = N, PL = PR  = 1.",
       "         If IJOB = 0, 2 or 3, PL and PR are not referenced."],
     "DIF"=>
      ["[out]",
       "         DIF is REAL array, dimension (2).",
       "         If IJOB >= 2, DIF(1:2) store the estimates of Difu and Difl.",
       "         If IJOB = 2 or 4, DIF(1:2) are F-norm-based upper bounds on",
       "         Difu and Difl. If IJOB = 3 or 5, DIF(1:2) are 1-norm-based",
       "         estimates of Difu and Difl.",
       "         If M = 0 or N, DIF(1:2) = F-norm([A, B]).",
       "         If IJOB = 0 or 1, DIF is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >=  4*N+16.",
       "         If IJOB = 1, 2 or 4, LWORK >= MAX(4*N+16, 2*M*(N-M)).",
       "         If IJOB = 3 or 5, LWORK >= MAX(4*N+16, 4*M*(N-M)).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK. LIWORK >= 1.",
       "         If IJOB = 1, 2 or 4, LIWORK >=  N+6.",
       "         If IJOB = 3 or 5, LIWORK >= MAX(2*M*(N-M), N+6).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "           =0: Successful exit.",
       "           <0: If INFO = -i, the i-th argument had an illegal value.",
       "           =1: Reordering of (A, B) failed because the transformed",
       "               matrix pair (A, B) would be too far from generalized",
       "               Schur form; the problem is very ill-conditioned.",
       "               (A, B) may have been partially reordered.",
       "               If requested, 0 is returned in DIF(*), PL and PR."]}},
 "zlatrs"=>
  {"summary"=>
    ["ZLATRS solves one of the triangular systems",
     "   A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b,",
     "with scaling to prevent overflow.  Here A is an upper or lower",
     "triangular matrix, A**T denotes the transpose of A, A**H denotes the",
     "conjugate transpose of A, x and b are n-element vectors, and s is a",
     "scaling factor, usually less than or equal to 1, chosen so that the",
     "components of x will be less than the overflow threshold.  If the",
     "unscaled problem will not cause overflow, the Level 2 BLAS routine",
     "ZTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j),",
     "then s is set to 0 and a non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b     (No transpose)",
       "         = 'T':  Solve A**T * x = s*b  (Transpose)",
       "         = 'C':  Solve A**H * x = s*b  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading n by n",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading n by n lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max (1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is DOUBLE PRECISION array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "dpotrf"=>
  {"summary"=>
    ["DPOTRF computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the block version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "zhb2st_kernels"=>
  {"summary"=>
    ["ZHB2ST_KERNELS is an internal routine used by the ZHETRD_HB2ST",
     "subroutine."],
   "param"=>nil},
 "zlatps"=>
  {"summary"=>
    ["ZLATPS solves one of the triangular systems",
     "   A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b,",
     "with scaling to prevent overflow, where A is an upper or lower",
     "triangular matrix stored in packed form.  Here A**T denotes the",
     "transpose of A, A**H denotes the conjugate transpose of A, x and b",
     "are n-element vectors, and s is a scaling factor, usually less than",
     "or equal to 1, chosen so that the components of x will be less than",
     "the overflow threshold.  If the unscaled problem will not cause",
     "overflow, the Level 2 BLAS routine ZTPSV is called. If the matrix A",
     "is singular (A(j,j) = 0 for some j), then s is set to 0 and a",
     "non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b     (No transpose)",
       "         = 'T':  Solve A**T * x = s*b  (Transpose)",
       "         = 'C':  Solve A**H * x = s*b  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is DOUBLE PRECISION array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "cpotrf2"=>
  {"summary"=>
    ["CPOTRF2 computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A using the recursive algorithm.",
     "The factorization has the form",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the recursive version of the algorithm. It divides",
     "the matrix into four submatrices:",
     "       [  A11 | A12  ]  where A11 is n1 by n1 and A22 is n2 by n2",
     "   A = [ -----|----- ]  with n1 = n/2",
     "       [  A21 | A22  ]       n2 = n-n1",
     "The subroutine calls itself to factor A11. Update and scale A21",
     "or A12, update A22 then calls itself to factor A22."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**H*U or A = L*L**H."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "zlahef_rook"=>
  {"summary"=>
    ["ZLAHEF_ROOK computes a partial factorization of a complex Hermitian",
     "matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting",
     "method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I      0     )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**H U22**H )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**H L21**H )  if UPLO = 'L'",
     "      ( L21  I ) (  0  A22 ) (  0      I     )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "Note that U**H denotes the conjugate transpose of U.",
     "ZLAHEF_ROOK is an auxiliary routine called by ZHETRF_ROOK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "W"=>["[out]", "         W is COMPLEX*16 array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "dlaexc"=>
  {"summary"=>
    ["DLAEXC swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in",
     "an upper quasi-triangular matrix T by an orthogonal similarity",
     "transformation.",
     "T must be in Schur canonical form, that is, block upper triangular",
     "with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block",
     "has its diagonal elemnts equal and its off-diagonal elements of",
     "opposite sign."],
   "param"=>
    {"WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         = .TRUE. : accumulate the transformation in the matrix Q;",
       "         = .FALSE.: do not accumulate the transformation."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in,out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         On entry, the upper quasi-triangular matrix T, in Schur",
       "         canonical form.",
       "         On exit, the updated matrix T, again in Schur canonical form."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         On entry, if WANTQ is .TRUE., the orthogonal matrix Q.",
       "         On exit, if WANTQ is .TRUE., the updated matrix Q.",
       "         If WANTQ is .FALSE., Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= 1; and if WANTQ is .TRUE., LDQ >= N."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The index of the first row of the first block T11."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         The order of the first block T11. N1 = 0, 1 or 2."],
     "N2"=>
      ["[in]",
       "         N2 is INTEGER",
       "         The order of the second block T22. N2 = 0, 1 or 2."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         = 1: the transformed matrix T would be too far from Schur",
       "              form; the blocks are not swapped and T and Q are",
       "              unchanged."]}},
 "zunmqr"=>
  {"summary"=>
    ["ZUNMQR overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by ZGEQRF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         ZGEQRF in the first k columns of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGEQRF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlasq3"=>
  {"summary"=>
    ["DLASQ3 checks for deflation, computes a shift (TAU) and calls dqds.",
     "In case of failure it changes shifts, and tries again until output",
     "is positive."],
   "param"=>
    {"I0"=>["[in]", "         I0 is INTEGER", "        First index."],
     "N0"=>["[in,out]", "         N0 is INTEGER", "        Last index."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension ( 4*N0 )",
       "        Z holds the qd array."],
     "PP"=>
      ["[in,out]",
       "         PP is INTEGER",
       "        PP=0 for ping, PP=1 for pong.",
       "        PP=2 indicates that flipping was applied to the Z array",
       "        and that the initial tests for deflation should not be",
       "        performed."],
     "DMIN"=>
      ["[out]",
       "         DMIN is DOUBLE PRECISION",
       "        Minimum value of d."],
     "SIGMA"=>
      ["[out]",
       "         SIGMA is DOUBLE PRECISION",
       "        Sum of shifts used in current segment."],
     "DESIG"=>
      ["[in,out]",
       "         DESIG is DOUBLE PRECISION",
       "        Lower order part of SIGMA"],
     "QMAX"=>
      ["[in]",
       "         QMAX is DOUBLE PRECISION",
       "        Maximum value of q."],
     "NFAIL"=>
      ["[in,out]",
       "         NFAIL is INTEGER",
       "        Increment NFAIL by 1 each time the shift was too big."],
     "ITER"=>
      ["[in,out]",
       "         ITER is INTEGER",
       "        Increment ITER by 1 for each iteration."],
     "NDIV"=>
      ["[in,out]",
       "         NDIV is INTEGER",
       "        Increment NDIV by 1 for each division."],
     "IEEE"=>
      ["[in]",
       "         IEEE is LOGICAL",
       "        Flag for IEEE or non IEEE arithmetic (passed to DLASQ5)."],
     "TTYPE"=>["[in,out]", "         TTYPE is INTEGER", "        Shift type."],
     "DMIN1"=>["[in,out]", "         DMIN1 is DOUBLE PRECISION"],
     "DMIN2"=>["[in,out]", "         DMIN2 is DOUBLE PRECISION"],
     "DN"=>["[in,out]", "         DN is DOUBLE PRECISION"],
     "DN1"=>["[in,out]", "         DN1 is DOUBLE PRECISION"],
     "DN2"=>["[in,out]", "         DN2 is DOUBLE PRECISION"],
     "G"=>["[in,out]", "         G is DOUBLE PRECISION"],
     "TAU"=>
      ["[in,out]",
       "         TAU is DOUBLE PRECISION",
       "        These are passed as arguments in order to save their values",
       "        between calls to DLASQ3."]}},
 "zla_gercond_c"=>
  {"summary"=>
    ["   ZLA_GERCOND_C computes the infinity norm condition number of",
     "   op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by ZGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by ZGETRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The vector C in the formula op(A) * inv(diag(C))."],
     "CAPPLY"=>
      ["[in]",
       "         CAPPLY is LOGICAL",
       "    If .TRUE. then access the vector C in the formula above."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX*16 array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is DOUBLE PRECISION array, dimension (N).",
       "    Workspace."]}},
 "ztgsyl"=>
  {"summary"=>
    ["ZTGSYL solves the generalized Sylvester equation:",
     "            A * R - L * B = scale * C            (1)",
     "            D * R - L * E = scale * F",
     "where R and L are unknown m-by-n matrices, (A, D), (B, E) and",
     "(C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n,",
     "respectively, with complex entries. A, B, D and E are upper",
     "triangular (i.e., (A,D) and (B,E) in generalized Schur form).",
     "The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1",
     "is an output scaling factor chosen to avoid overflow.",
     "In matrix notation (1) is equivalent to solve Zx = scale*b, where Z",
     "is defined as",
     "       Z = [ kron(In, A)  -kron(B**H, Im) ]        (2)",
     "           [ kron(In, D)  -kron(E**H, Im) ],",
     "Here Ix is the identity matrix of size x and X**H is the conjugate",
     "transpose of X. Kron(X, Y) is the Kronecker product between the",
     "matrices X and Y.",
     "If TRANS = 'C', y in the conjugate transposed system Z**H *y = scale*b",
     "is solved for, which is equivalent to solve for R and L in",
     "            A**H * R + D**H * L = scale * C           (3)",
     "            R * B**H + L * E**H = scale * -F",
     "This case (TRANS = 'C') is used to compute an one-norm-based estimate",
     "of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D)",
     "and (B,E), using ZLACON.",
     "If IJOB >= 1, ZTGSYL computes a Frobenius norm-based estimate of",
     "Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the",
     "reciprocal of the smallest singular value of Z.",
     "This is a level-3 BLAS algorithm."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': solve the generalized sylvester equation (1).",
       "         = 'C': solve the \"conjugate transposed\" system (3)."],
     "IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies what kind of functionality to be performed.",
       "         =0: solve (1) only.",
       "         =1: The functionality of 0 and 3.",
       "         =2: The functionality of 0 and 4.",
       "         =3: Only an estimate of Dif[(A,D), (B,E)] is computed.",
       "             (look ahead strategy is used).",
       "         =4: Only an estimate of Dif[(A,D), (B,E)] is computed.",
       "             (ZGECON on sub-systems is used).",
       "         Not referenced if TRANS = 'C'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The order of the matrices A and D, and the row dimension of",
       "         the matrices C, F, R and L."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices B and E, and the column dimension",
       "         of the matrices C, F, R and L."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA, M)",
       "         The upper triangular matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1, M)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         The upper triangular matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1, N)."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC, N)",
       "         On entry, C contains the right-hand-side of the first matrix",
       "         equation in (1) or (3).",
       "         On exit, if IJOB = 0, 1 or 2, C has been overwritten by",
       "         the solution R. If IJOB = 3 or 4 and TRANS = 'N', C holds R,",
       "         the solution achieved during the computation of the",
       "         Dif-estimate."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1, M)."],
     "D"=>
      ["[in]",
       "         D is COMPLEX*16 array, dimension (LDD, M)",
       "         The upper triangular matrix D."],
     "LDD"=>
      ["[in]",
       "         LDD is INTEGER",
       "         The leading dimension of the array D. LDD >= max(1, M)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (LDE, N)",
       "         The upper triangular matrix E."],
     "LDE"=>
      ["[in]",
       "         LDE is INTEGER",
       "         The leading dimension of the array E. LDE >= max(1, N)."],
     "F"=>
      ["[in,out]",
       "         F is COMPLEX*16 array, dimension (LDF, N)",
       "         On entry, F contains the right-hand-side of the second matrix",
       "         equation in (1) or (3).",
       "         On exit, if IJOB = 0, 1 or 2, F has been overwritten by",
       "         the solution L. If IJOB = 3 or 4 and TRANS = 'N', F holds L,",
       "         the solution achieved during the computation of the",
       "         Dif-estimate."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the array F. LDF >= max(1, M)."],
     "DIF"=>
      ["[out]",
       "         DIF is DOUBLE PRECISION",
       "         On exit DIF is the reciprocal of a lower bound of the",
       "         reciprocal of the Dif-function, i.e. DIF is an upper bound of",
       "         Dif[(A,D), (B,E)] = sigma-min(Z), where Z as in (2).",
       "         IF IJOB = 0 or TRANS = 'C', DIF is not referenced."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         On exit SCALE is the scaling factor in (1) or (3).",
       "         If 0 < SCALE < 1, C and F hold the solutions R and L, resp.,",
       "         to a slightly perturbed system but the input matrices A, B,",
       "         D and E have not been changed. If SCALE = 0, R and L will",
       "         hold the solutions to the homogenious system with C = F = 0."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK > = 1.",
       "         If IJOB = 1 or 2 and TRANS = 'N', LWORK >= max(1,2*M*N).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (M+N+2)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "           =0: successful exit",
       "           <0: If INFO = -i, the i-th argument had an illegal value.",
       "           >0: (A, D) and (B, E) have common or very close",
       "               eigenvalues."]}},
 "zsytrs"=>
  {"summary"=>
    ["ZSYTRS solves a system of linear equations A*X = B with a complex",
     "symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by ZSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sstevd"=>
  {"summary"=>
    ["SSTEVD computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric tridiagonal matrix. If eigenvectors are desired, it",
     "uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A, stored in elements 1 to N-1 of E.",
       "         On exit, the contents of E are destroyed."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with D(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array,",
       "                                        dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If JOBZ  = 'N' or N <= 1 then LWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1 then LWORK must be at least",
       "                        ( 1 + 4*N + N**2 ).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1 then LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1 then LIWORK must be at least 3+5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of E did not converge to zero."]}},
 "dlaruv"=>
  {"summary"=>
    ["DLARUV returns a vector of n random real numbers from a uniform (0,1)",
     "distribution (n <= 128).",
     "This is an auxiliary routine called by DLARNV and ZLARNV."],
   "param"=>
    {"ISEED"=>
      ["[in,out]",
       "         ISEED is INTEGER array, dimension (4)",
       "         On entry, the seed of the random number generator; the array",
       "         elements must be between 0 and 4095, and ISEED(4) must be",
       "         odd.",
       "         On exit, the seed is updated."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of random numbers to be generated. N <= 128."],
     "X"=>
      ["[out]",
       "         X is DOUBLE PRECISION array, dimension (N)",
       "         The generated random numbers."]}},
 "dgelq2"=>
  {"summary"=>
    ["DGELQ2 computes an LQ factorization of a real m by n matrix A:",
     "A = L * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the m by min(m,n) lower trapezoidal matrix L (L is",
       "         lower triangular if m <= n); the elements above the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "slapy2"=>
  {"summary"=>
    ["SLAPY2 returns sqrt(x**2+y**2), taking care not to cause unnecessary",
     "overflow."],
   "param"=>
    {"X"=>["[in]", "         X is REAL"],
     "Y"=>
      ["[in]",
       "         Y is REAL",
       "         X and Y specify the values x and y."]}},
 "ssbevx_2stage"=>
  {"summary"=>
    ["SSBEVX_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric band matrix A using the 2stage technique for",
     "the reduction to tridiagonal. Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "Q"=>
      ["[out]",
       "         Q is REAL array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the N-by-N orthogonal matrix used in the",
       "                        reduction to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'V', then",
       "         LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AB to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, 7*N, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS + 2*N",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "dtrttf"=>
  {"summary"=>
    ["DTRTTF copies a triangular matrix A from standard full format (TR)",
     "to rectangular full packed format (TF) ."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF in Normal form is wanted;",
       "         = 'T':  ARF in Transpose form is wanted."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N).",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the matrix A. LDA >= max(1,N)."],
     "ARF"=>
      ["[out]",
       "         ARF is DOUBLE PRECISION array, dimension (NT).",
       "         NT=N*(N+1)/2. On exit, the triangular matrix A in RFP format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sisnan"=>
  {"summary"=>
    ["SISNAN returns .TRUE. if its argument is NaN, and .FALSE.",
     "otherwise.  To be replaced by the Fortran 2003 intrinsic in the",
     "future."],
   "param"=>
    {"SIN"=>
      ["[in]", "         SIN is REAL", "         Input to test for NaN."]}},
 "dla_gercond"=>
  {"summary"=>
    ["   DLA_GERCOND estimates the Skeel condition number of op(A) * op2(C)",
     "   where op2 is determined by CMODE as follows",
     "   CMODE =  1    op2(C) = C",
     "   CMODE =  0    op2(C) = I",
     "   CMODE = -1    op2(C) = inv(C)",
     "   The Skeel condition number cond(A) = norminf( |inv(A)||A| )",
     "   is computed by computing scaling factors R such that",
     "   diag(R)*A*op2(C) is row equilibrated and computing the standard",
     "   infinity-norm condition number."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by DGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by DGETRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "CMODE"=>
      ["[in]",
       "         CMODE is INTEGER",
       "    Determines op2(C) in the formula op(A) * op2(C) as follows:",
       "    CMODE =  1    op2(C) = C",
       "    CMODE =  0    op2(C) = I",
       "    CMODE = -1    op2(C) = inv(C)"],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The vector C in the formula op(A) * op2(C)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is DOUBLE PRECISION array, dimension (3*N).",
       "    Workspace."],
     "IWORK"=>
      ["[in]",
       "         IWORK is INTEGER array, dimension (N).",
       "    Workspace."]}},
 "sorghr"=>
  {"summary"=>
    ["SORGHR generates a real orthogonal matrix Q which is defined as the",
     "product of IHI-ILO elementary reflectors of order N, as returned by",
     "SGEHRD:",
     "Q = H(ilo) H(ilo+1) . . . H(ihi-1)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI must have the same values as in the previous call",
       "         of SGEHRD. Q is equal to the unit matrix except in the",
       "         submatrix Q(ilo+1:ihi,ilo+1:ihi).",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by SGEHRD.",
       "         On exit, the N-by-N orthogonal matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGEHRD."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= IHI-ILO.",
       "         For optimum performance LWORK >= (IHI-ILO)*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgelq"=>
  {"summary"=>["CGELQ computes a LQ factorization of an M-by-N matrix A."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the M-by-min(M,N) lower trapezoidal matrix L",
       "         (L is lower triangular if M <= N);",
       "         the elements above the diagonal are used to store part of the ",
       "         data structure to represent Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (MAX(5,TSIZE))",
       "         On exit, if INFO = 0, T(1) returns optimal (or either minimal ",
       "         or optimal, if query is assumed) TSIZE. See TSIZE for details.",
       "         Remaining T contains part of the data structure used to represent Q.",
       "         If one wants to apply or construct Q, then one needs to keep T ",
       "         (in addition to A) and pass it to further subroutines."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         If TSIZE >= 5, the dimension of the array T.",
       "         If TSIZE = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If TSIZE = -1, the routine calculates optimal size of T for the ",
       "         optimum performance and returns this value in T(1).",
       "         If TSIZE = -2, the routine calculates minimal size of T and ",
       "         returns this value in T(1)."],
     "WORK"=>
      ["[out]",
       "         (workspace) COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "stftri"=>
  {"summary"=>
    ["STFTRI computes the inverse of a triangular matrix A stored in RFP",
     "format.",
     "This is a Level 3 BLAS version of the algorithm."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'T':  The Transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (NT);",
       "         NT=N*(N+1)/2. On entry, the triangular factor of a Hermitian",
       "         Positive Definite matrix A in RFP format. RFP format is",
       "         described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'",
       "         then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'T' then RFP is",
       "         the transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the nt elements of",
       "         upper packed A; If UPLO = 'L' the RFP A contains the nt",
       "         elements of lower packed A. The LDA of RFP A is (N+1)/2 when",
       "         TRANSR = 'T'. When TRANSR is 'N' the LDA is N+1 when N is",
       "         even and N is odd. See the Note below for more details.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, A(i,i) is exactly zero.  The triangular",
       "              matrix is singular and its inverse can not be computed."]}},
 "dlarrb"=>
  {"summary"=>
    ["Given the relatively robust representation(RRR) L D L^T, DLARRB",
     "does \"limited\" bisection to refine the eigenvalues of L D L^T,",
     "W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial",
     "guesses for these eigenvalues are input in W, the corresponding estimate",
     "of the error in these guesses and their gaps are input in WERR",
     "and WGAP, respectively. During bisection, intervals",
     "[left, right] are maintained by storing their mid-points and",
     "semi-widths in the arrays W and WERR respectively."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The N diagonal elements of the diagonal matrix D."],
     "LLD"=>
      ["[in]",
       "         LLD is DOUBLE PRECISION array, dimension (N-1)",
       "         The (N-1) elements L(i)*L(i)*D(i)."],
     "IFIRST"=>
      ["[in]",
       "         IFIRST is INTEGER",
       "         The index of the first eigenvalue to be computed."],
     "ILAST"=>
      ["[in]",
       "         ILAST is INTEGER",
       "         The index of the last eigenvalue to be computed."],
     "RTOL1"=>["[in]", "         RTOL1 is DOUBLE PRECISION"],
     "RTOL2"=>
      ["[in]",
       "         RTOL2 is DOUBLE PRECISION",
       "         Tolerance for the convergence of the bisection intervals.",
       "         An interval [LEFT,RIGHT] has converged if",
       "         RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )",
       "         where GAP is the (estimated) distance to the nearest",
       "         eigenvalue."],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         Offset for the arrays W, WGAP and WERR, i.e., the IFIRST-OFFSET",
       "         through ILAST-OFFSET elements of these arrays are to be used."],
     "W"=>
      ["[in,out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         On input, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ) are",
       "         estimates of the eigenvalues of L D L^T indexed IFIRST throug",
       "         ILAST.",
       "         On output, these estimates are refined."],
     "WGAP"=>
      ["[in,out]",
       "         WGAP is DOUBLE PRECISION array, dimension (N-1)",
       "         On input, the (estimated) gaps between consecutive",
       "         eigenvalues of L D L^T, i.e., WGAP(I-OFFSET) is the gap between",
       "         eigenvalues I and I+1. Note that if IFIRST.EQ.ILAST",
       "         then WGAP(IFIRST-OFFSET) must be set to ZERO.",
       "         On output, these gaps are refined."],
     "WERR"=>
      ["[in,out]",
       "         WERR is DOUBLE PRECISION array, dimension (N)",
       "         On input, WERR( IFIRST-OFFSET ) through WERR( ILAST-OFFSET ) are",
       "         the errors in the estimates of the corresponding elements in W.",
       "         On output, these errors are refined."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (2*N)",
       "         Workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (2*N)",
       "         Workspace."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "         The minimum pivot in the Sturm sequence."],
     "SPDIAM"=>
      ["[in]",
       "         SPDIAM is DOUBLE PRECISION",
       "         The spectral diameter of the matrix."],
     "TWIST"=>
      ["[in]",
       "         TWIST is INTEGER",
       "         The twist index for the twisted factorization that is used",
       "         for the negcount.",
       "         TWIST = N: Compute negcount from L D L^T - LAMBDA I = L+ D+ L+^T",
       "         TWIST = 1: Compute negcount from L D L^T - LAMBDA I = U- D- U-^T",
       "         TWIST = R: Compute negcount from L D L^T - LAMBDA I = N(r) D(r) N(r)"],
     "INFO"=>["[out]", "         INFO is INTEGER", "         Error flag."]}},
 "ztptrs"=>
  {"summary"=>
    ["ZTPTRS solves a triangular system of the form",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B,",
     "where A is a triangular matrix of order N stored in packed format,",
     "and B is an N-by-NRHS matrix.  A check is made to verify that A is",
     "nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element of A is zero,",
       "               indicating that the matrix is singular and the",
       "               solutions X have not been computed."]}},
 "dlatsqr"=>
  {"summary"=>
    ["DLATSQR computes a blocked Tall-Skinny QR factorization of",
     "an M-by-N matrix A, where M >= N:",
     "A = Q * R ."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. M >= N >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         MB > N."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal",
       "         of the array contain the N-by-N upper triangular matrix R;",
       "         the elements below the diagonal represent Q by the columns",
       "         of blocked V (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array,",
       "         dimension (LDT, N * Number_of_row_blocks)",
       "         where Number_of_row_blocks = CEIL((M-N)/(MB-N))",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.",
       "         See Further Details below."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>
      ["[out]",
       "        (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         The dimension of the array WORK.  LWORK >= NB*N.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sstein"=>
  {"summary"=>
    ["SSTEIN computes the eigenvectors of a real symmetric tridiagonal",
     "matrix T corresponding to specified eigenvalues, using inverse",
     "iteration.",
     "The maximum number of iterations allowed for each eigenvector is",
     "specified by an internal parameter MAXITS (currently set to 5)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the tridiagonal matrix",
       "         T, in elements 1 to N-1."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of eigenvectors to be found.  0 <= M <= N."],
     "W"=>
      ["[in]",
       "         W is REAL array, dimension (N)",
       "         The first M elements of W contain the eigenvalues for",
       "         which eigenvectors are to be computed.  The eigenvalues",
       "         should be grouped by split-off block and ordered from",
       "         smallest to largest within the block.  ( The output array",
       "         W from SSTEBZ with ORDER = 'B' is expected here. )"],
     "IBLOCK"=>
      ["[in]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         The submatrix indices associated with the corresponding",
       "         eigenvalues in W; IBLOCK(i)=1 if eigenvalue W(i) belongs to",
       "         the first submatrix from the top, =2 if W(i) belongs to",
       "         the second submatrix, etc.  ( The output array IBLOCK",
       "         from SSTEBZ is expected here. )"],
     "ISPLIT"=>
      ["[in]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into submatrices.",
       "         The first submatrix consists of rows/columns 1 to",
       "         ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1",
       "         through ISPLIT( 2 ), etc.",
       "         ( The output array ISPLIT from SSTEBZ is expected here. )"],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, M)",
       "         The computed eigenvectors.  The eigenvector associated",
       "         with the eigenvalue W(i) is stored in the i-th column of",
       "         Z.  Any vector which fails to converge is set to its current",
       "         iterate after MAXITS iterations."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (5*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (M)",
       "         On normal exit, all elements of IFAIL are zero.",
       "         If one or more eigenvectors fail to converge after",
       "         MAXITS iterations, then their indices are stored in",
       "         array IFAIL."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit.",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, then i eigenvectors failed to converge",
       "              in MAXITS iterations.  Their indices are stored in",
       "              array IFAIL."]}},
 "sormqr"=>
  {"summary"=>
    ["SORMQR overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by SGEQRF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         SGEQRF in the first k columns of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGEQRF."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhprfs"=>
  {"summary"=>
    ["ZHPRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian indefinite",
     "and packed, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the Hermitian matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n."],
     "AFP"=>
      ["[in]",
       "         AFP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The factored form of the matrix A.  AFP contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**H or",
       "         A = L*D*L**H as computed by ZHPTRF, stored as a packed",
       "         triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHPTRF."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by ZHPTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgeqrf"=>
  {"summary"=>
    ["SGEQRF computes a QR factorization of a real M-by-N matrix A:",
     "A = Q * R."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n); the elements below the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of min(m,n) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhbgst"=>
  {"summary"=>
    ["ZHBGST reduces a complex Hermitian-definite banded generalized",
     "eigenproblem  A*x = lambda*B*x  to standard form  C*y = lambda*y,",
     "such that C has the same bandwidth as A.",
     "B must have been previously factorized as S**H*S by ZPBSTF, using a",
     "split Cholesky factorization. A is overwritten by C = X**H*A*X, where",
     "X = S**(-1)*Q and Q is a unitary matrix chosen to preserve the",
     "bandwidth of A."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  do not form the transformation matrix X;",
       "         = 'V':  form X."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the transformed matrix X**H*A*X, stored in the same",
       "         format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in]",
       "         BB is COMPLEX*16 array, dimension (LDBB,N)",
       "         The banded factor S from the split Cholesky factorization of",
       "         B, as returned by ZPBSTF, stored in the first kb+1 rows of",
       "         the array."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "X"=>
      ["[out]",
       "         X is COMPLEX*16 array, dimension (LDX,N)",
       "         If VECT = 'V', the n-by-n matrix X.",
       "         If VECT = 'N', the array X is not referenced."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.",
       "         LDX >= max(1,N) if VECT = 'V'; LDX >= 1 otherwise."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zgeqrf"=>
  {"summary"=>
    ["ZGEQRF computes a QR factorization of a complex M-by-N matrix A:",
     "A = Q * R."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n); the elements below the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of min(m,n) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ctgexc"=>
  {"summary"=>
    ["CTGEXC reorders the generalized Schur decomposition of a complex",
     "matrix pair (A,B), using an unitary equivalence transformation",
     "(A, B) := Q * (A, B) * Z**H, so that the diagonal block of (A, B) with",
     "row index IFST is moved to row ILST.",
     "(A, B) must be in generalized Schur canonical form, that is, A and",
     "B are both upper triangular.",
     "Optionally, the matrices Q and Z of generalized Schur vectors are",
     "updated.",
     "       Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H",
     "       Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H"],
   "param"=>
    {"WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the upper triangular matrix A in the pair (A, B).",
       "         On exit, the updated matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the upper triangular matrix B in the pair (A, B).",
       "         On exit, the updated matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDZ,N)",
       "         On entry, if WANTQ = .TRUE., the unitary matrix Q.",
       "         On exit, the updated matrix Q.",
       "         If WANTQ = .FALSE., Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= 1;",
       "         If WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ,N)",
       "         On entry, if WANTZ = .TRUE., the unitary matrix Z.",
       "         On exit, the updated matrix Z.",
       "         If WANTZ = .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1;",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "IFST"=>["[in]", "         IFST is INTEGER"],
     "ILST"=>
      ["[in,out]",
       "         ILST is INTEGER",
       "         Specify the reordering of the diagonal blocks of (A, B).",
       "         The block with row index IFST is moved to row ILST, by a",
       "         sequence of swapping between adjacent blocks."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          =0:  Successful exit.",
       "          <0:  if INFO = -i, the i-th argument had an illegal value.",
       "          =1:  The transformed matrix pair (A, B) would be too far",
       "               from generalized Schur form; the problem is ill-",
       "               conditioned. (A, B) may have been partially reordered,",
       "               and ILST points to the first row of the current",
       "               position of the block being moved."]}},
 "dsycon_rook"=>
  {"summary"=>
    ["DSYCON_ROOK estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric matrix A using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by DSYTRF_ROOK.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by DSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF_ROOK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clarft"=>
  {"summary"=>
    ["CLARFT forms the triangular factor T of a complex block reflector H",
     "of order n, which is defined as a product of k elementary reflectors.",
     "If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;",
     "If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.",
     "If STOREV = 'C', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th column of the array V, and",
     "   H  =  I - V * T * V**H",
     "If STOREV = 'R', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th row of the array V, and",
     "   H  =  I - V**H * T * V"],
   "param"=>
    {"DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies the order in which the elementary reflectors are",
       "         multiplied to form the block reflector:",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Specifies how the vectors which define the elementary",
       "         reflectors are stored (see also Further Details):",
       "         = 'C': columnwise",
       "         = 'R': rowwise"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the block reflector H. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the triangular factor T (= the number of",
       "         elementary reflectors). K >= 1."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension",
       "                              (LDV,K) if STOREV = 'C'",
       "                              (LDV,N) if STOREV = 'R'",
       "         The matrix V. See further details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,K)",
       "         The k by k triangular factor T of the block reflector.",
       "         If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is",
       "         lower triangular. The rest of the array is not used."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."]}},
 "ssycon_rook"=>
  {"summary"=>
    ["SSYCON_ROOK estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric matrix A using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by SSYTRF_ROOK.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by SSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF_ROOK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cppcon"=>
  {"summary"=>
    ["CPPCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex Hermitian positive definite packed matrix using",
     "the Cholesky factorization A = U**H*U or A = L*L**H computed by",
     "CPPTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H, packed columnwise in a linear",
       "         array.  The j-th column of U or L is stored in the array AP",
       "         as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm (or infinity-norm) of the Hermitian matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zunbdb6"=>
  {"summary"=>[],
   "param"=>
    {"M1"=>
      ["[in]",
       "         M1 is INTEGER",
       "          The dimension of X1 and the number of rows in Q1. 0 <= M1."],
     "M2"=>
      ["[in]",
       "         M2 is INTEGER",
       "          The dimension of X2 and the number of rows in Q2. 0 <= M2."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The number of columns in Q1 and Q2. 0 <= N."],
     "X1"=>
      ["[in,out]",
       "         X1 is COMPLEX*16 array, dimension (M1)",
       "          On entry, the top part of the vector to be orthogonalized.",
       "          On exit, the top part of the projected vector."],
     "INCX1"=>
      ["[in]",
       "         INCX1 is INTEGER",
       "          Increment for entries of X1."],
     "X2"=>
      ["[in,out]",
       "         X2 is COMPLEX*16 array, dimension (M2)",
       "          On entry, the bottom part of the vector to be",
       "          orthogonalized. On exit, the bottom part of the projected",
       "          vector."],
     "INCX2"=>
      ["[in]",
       "         INCX2 is INTEGER",
       "          Increment for entries of X2."],
     "Q1"=>
      ["[in]",
       "         Q1 is COMPLEX*16 array, dimension (LDQ1, N)",
       "          The top part of the orthonormal basis matrix."],
     "LDQ1"=>
      ["[in]",
       "         LDQ1 is INTEGER",
       "          The leading dimension of Q1. LDQ1 >= M1."],
     "Q2"=>
      ["[in]",
       "         Q2 is COMPLEX*16 array, dimension (LDQ2, N)",
       "          The bottom part of the orthonormal basis matrix."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "          The leading dimension of Q2. LDQ2 >= M2."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "cposvxx"=>
  {"summary"=>
    ["   CPOSVXX uses the Cholesky factorization A = U**T*U or A = L*L**T",
     "   to compute the solution to a complex system of linear equations",
     "   A * X = B, where A is an N-by-N symmetric positive definite matrix",
     "   and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. CPOSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   CPOSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   CPOSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what CPOSVXX would itself produce."],
   "param"=>nil},
 "sgetrf"=>
  {"summary"=>
    ["SGETRF computes an LU factorization of a general M-by-N matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the right-looking Level 3 BLAS version of the algorithm."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "strsyl"=>
  {"summary"=>
    ["STRSYL solves the real Sylvester matrix equation:",
     "   op(A)*X + X*op(B) = scale*C or",
     "   op(A)*X - X*op(B) = scale*C,",
     "where op(A) = A or A**T, and  A and B are both upper quasi-",
     "triangular. A is M-by-M and B is N-by-N; the right hand side C and",
     "the solution X are M-by-N; and scale is an output scale factor, set",
     "<= 1 to avoid overflow in X.",
     "A and B must be in Schur canonical form (as returned by SHSEQR), that",
     "is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks;",
     "each 2-by-2 diagonal block has its diagonal elements equal and its",
     "off-diagonal elements of opposite sign."],
   "param"=>
    {"TRANA"=>
      ["[in]",
       "         TRANA is CHARACTER*1",
       "         Specifies the option op(A):",
       "         = 'N': op(A) = A    (No transpose)",
       "         = 'T': op(A) = A**T (Transpose)",
       "         = 'C': op(A) = A**H (Conjugate transpose = Transpose)"],
     "TRANB"=>
      ["[in]",
       "         TRANB is CHARACTER*1",
       "         Specifies the option op(B):",
       "         = 'N': op(B) = B    (No transpose)",
       "         = 'T': op(B) = B**T (Transpose)",
       "         = 'C': op(B) = B**H (Conjugate transpose = Transpose)"],
     "ISGN"=>
      ["[in]",
       "         ISGN is INTEGER",
       "         Specifies the sign in the equation:",
       "         = +1: solve op(A)*X + X*op(B) = scale*C",
       "         = -1: solve op(A)*X - X*op(B) = scale*C"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The order of the matrix A, and the number of rows in the",
       "         matrices X and C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix B, and the number of columns in the",
       "         matrices X and C. N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,M)",
       "         The upper quasi-triangular matrix A, in Schur canonical form."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,N)",
       "         The upper quasi-triangular matrix B, in Schur canonical form."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N right hand side matrix C.",
       "         On exit, C is overwritten by the solution matrix X."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)"],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         The scale factor, scale, set <= 1 to avoid overflow in X."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         = 1: A and B have common or very close eigenvalues; perturbed",
       "              values were used to solve the equation (but the matrices",
       "              A and B are unchanged)."]}},
 "zpftrs"=>
  {"summary"=>
    ["ZPFTRS solves a system of linear equations A*X = B with a Hermitian",
     "positive definite matrix A using the Cholesky factorization",
     "A = U**H*U or A = L*L**H computed by ZPFTRF."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of RFP A is stored;",
       "         = 'L':  Lower triangle of RFP A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension ( N*(N+1)/2 );",
       "         The triangular factor U or L from the Cholesky factorization",
       "         of RFP A = U**H*U or RFP A = L*L**H, as computed by ZPFTRF.",
       "         See note below for more details about RFP A."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgeql2"=>
  {"summary"=>
    ["SGEQL2 computes a QL factorization of a real m by n matrix A:",
     "A = Q * L."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, if m >= n, the lower triangle of the subarray",
       "         A(m-n+1:m,1:n) contains the n by n lower triangular matrix L;",
       "         if m <= n, the elements on and below the (n-m)-th",
       "         superdiagonal contain the m by n lower trapezoidal matrix L;",
       "         the remaining elements, with the array TAU, represent the",
       "         orthogonal matrix Q as a product of elementary reflectors",
       "         (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zhetri_3x"=>
  {"summary"=>
    ["ZHETRI_3X computes the inverse of a complex Hermitian indefinite",
     "matrix A using the factorization computed by ZHETRF_RK or ZHETRF_BK:",
     "    A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by ZHETRF_RK and ZHETRF_BK:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the Hermitian inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHETRF_RK or ZHETRF_BK."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX*16 array, dimension (N+NB+1,NB+3)."],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "dgetri"=>
  {"summary"=>
    ["DGETRI computes the inverse of a matrix using the LU factorization",
     "computed by DGETRF.",
     "This method inverts U and then computes inv(A) by solving the system",
     "inv(A)*L = inv(U) for inv(A)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the factors L and U from the factorization",
       "         A = P*L*U as computed by DGETRF.",
       "         On exit, if INFO = 0, the inverse of the original matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from DGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO=0, then WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimal performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero; the matrix is",
       "               singular and its inverse could not be computed."]}},
 "clangt"=>
  {"summary"=>
    ["CLANGT  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex tridiagonal matrix A.",
     "   CLANGT = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANGT as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANGT is",
       "         set to zero."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX array, dimension (N-1)",
       "         The (n-1) sub-diagonal elements of A."],
     "D"=>
      ["[in]",
       "         D is COMPLEX array, dimension (N)",
       "         The diagonal elements of A."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX array, dimension (N-1)",
       "         The (n-1) super-diagonal elements of A."]}},
 "chpgvx"=>
  {"summary"=>
    ["CHPGVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be Hermitian, stored in packed format, and B is also",
     "positive definite.  Eigenvalues and eigenvectors can be selected by",
     "specifying either a range of values or a range of indices for the",
     "desired eigenvalues."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H, in the same storage",
       "         format as B."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AP to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  CPPTRF or CHPEVX returned an error code:",
       "            <= N:  if INFO = i, CHPEVX failed to converge;",
       "                   i eigenvectors failed to converge.  Their indices",
       "                   are stored in array IFAIL.",
       "            > N:   if INFO = N + i, for 1 <= i <= n, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "cpttrs"=>
  {"summary"=>
    ["CPTTRS solves a tridiagonal system of the form",
     "   A * X = B",
     "using the factorization A = U**H*D*U or A = L*D*L**H computed by CPTTRF.",
     "D is a diagonal matrix specified in the vector D, U (or L) is a unit",
     "bidiagonal matrix whose superdiagonal (subdiagonal) is specified in",
     "the vector E, and X and B are N by NRHS matrices."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the form of the factorization and whether the",
       "         vector E is the superdiagonal of the upper bidiagonal factor",
       "         U or the subdiagonal of the lower bidiagonal factor L.",
       "         = 'U':  A = U**H*D*U, E is the superdiagonal of U",
       "         = 'L':  A = L*D*L**H, E is the subdiagonal of L"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         factorization A = U**H*D*U or A = L*D*L**H."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N-1)",
       "         If UPLO = 'U', the (n-1) superdiagonal elements of the unit",
       "         bidiagonal factor U from the factorization A = U**H*D*U.",
       "         If UPLO = 'L', the (n-1) subdiagonal elements of the unit",
       "         bidiagonal factor L from the factorization A = L*D*L**H."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side vectors B for the system of",
       "         linear equations.",
       "         On exit, the solution vectors, X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "cpbstf"=>
  {"summary"=>
    ["CPBSTF computes a split Cholesky factorization of a complex",
     "Hermitian positive definite band matrix A.",
     "This routine is designed to be used in conjunction with CHBGST.",
     "The factorization has the form  A = S**H*S  where S is a band matrix",
     "of the same bandwidth as A and the following structure:",
     "  S = ( U    )",
     "      ( M  L )",
     "where U is upper triangular of order m = (n+kd)/2, and L is lower",
     "triangular of order n-m."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first kd+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the factor S from the split Cholesky",
       "         factorization A = S**H*S. See Further Details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, the factorization could not be completed,",
       "              because the updated element a(i,i) was negative; the",
       "              matrix A is not positive definite."]}},
 "cgehrd"=>
  {"summary"=>
    ["CGEHRD reduces a complex general matrix A to upper Hessenberg form H by",
     "an unitary similarity transformation:  Q**H * A * Q = H ."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that A is already upper triangular in rows",
       "         and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "         set by a previous call to CGEBAL; otherwise they should be",
       "         set to 1 and N respectively. See Further Details.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         elements below the first subdiagonal, with the array TAU,",
       "         represent the unitary matrix Q as a product of elementary",
       "         reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details). Elements 1:ILO-1 and IHI:N-1 of TAU are set to",
       "         zero."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,N).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zhbgvd"=>
  {"summary"=>
    ["ZHBGVD computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite banded eigenproblem, of",
     "the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian",
     "and banded, and B is also positive definite.  If eigenvectors are",
     "desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is COMPLEX*16 array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(kb+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**H*S, as returned by ZPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i). The eigenvectors are",
       "         normalized so that Z**H*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO=0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LWORK >= N.",
       "         If JOBZ = 'V' and N > 1, LWORK >= 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO=0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK.",
       "         If N <= 1,               LRWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LRWORK >= N.",
       "         If JOBZ = 'V' and N > 1, LRWORK >= 1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO=0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of array IWORK.",
       "         If JOBZ = 'N' or N <= 1, LIWORK >= 1.",
       "         If JOBZ = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is:",
       "            <= N:  the algorithm failed to converge:",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then ZPBSTF",
       "                   returned INFO = i: B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "zhesv_rook"=>
  {"summary"=>
    ["ZHESV_ROOK computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS",
     "matrices.",
     "The bounded Bunch-Kaufman (\"rook\") diagonal pivoting method is used",
     "to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is Hermitian and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "ZHETRF_ROOK is called to compute the factorization of a complex",
     "Hermition matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal",
     "pivoting method.",
     "The factored form of A is then used to solve the system",
     "of equations A * X = B by calling ZHETRS_ROOK (uses BLAS 2)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**H or A = L*D*L**H as computed by",
       "         ZHETRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         ZHETRF_ROOK.",
       "         for LWORK < N, TRS will be done with Level BLAS 2",
       "         for LWORK >= N, TRS will be done with Level BLAS 3",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed.",
       " November 2013,  Igor Kozachenko,",
       "                 Computer Science Division,",
       "                 University of California, Berkeley",
       " September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas,",
       "                 School of Mathematics,",
       "                 University of Manchester"]}},
 "zhesvx"=>
  {"summary"=>
    ["ZHESVX uses the diagonal pivoting factorization to compute the",
     "solution to a complex system of linear equations A * X = B,",
     "where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS",
     "matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "zsytri_3"=>
  {"summary"=>
    ["ZSYTRI_3 computes the inverse of a complex symmetric indefinite",
     "matrix A using the factorization computed by ZSYTRF_RK or ZSYTRF_BK:",
     "    A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "ZSYTRI_3 sets the leading dimension of the workspace  before calling",
     "ZSYTRI_3X that actually computes the inverse.  This is the blocked",
     "version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by ZSYTRF_RK and ZSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the symmetric inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF_RK or ZSYTRF_BK."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (N+NB+1)*(NB+3).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK. LWORK >= (N+NB+1)*(NB+3).",
       "         If LDWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the optimal",
       "         size of the WORK array, returns this value as the first",
       "         entry of the WORK array, and no error message related to",
       "         LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "ztpcon"=>
  {"summary"=>
    ["ZTPCON estimates the reciprocal of the condition number of a packed",
     "triangular matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlar2v"=>
  {"summary"=>
    ["DLAR2V applies a vector of real plane rotations from both sides to",
     "a sequence of 2-by-2 real symmetric matrices, defined by the elements",
     "of the vectors x, y and z. For i = 1,2,...,n",
     "   ( x(i)  z(i) ) := (  c(i)  s(i) ) ( x(i)  z(i) ) ( c(i) -s(i) )",
     "   ( z(i)  y(i) )    ( -s(i)  c(i) ) ( z(i)  y(i) ) ( s(i)  c(i) )"],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be applied."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array,",
       "                        dimension (1+(N-1)*INCX)",
       "         The vector x."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array,",
       "                        dimension (1+(N-1)*INCX)",
       "         The vector y."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array,",
       "                        dimension (1+(N-1)*INCX)",
       "         The vector z."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X, Y and Z. INCX > 0."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension (1+(N-1)*INCC)",
       "         The sines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C and S. INCC > 0."]}},
 "zptrfs"=>
  {"summary"=>
    ["ZPTRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian positive definite",
     "and tridiagonal, and provides error bounds and backward error",
     "estimates for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the superdiagonal or the subdiagonal of the",
       "         tridiagonal matrix A is stored and the form of the",
       "         factorization:",
       "         = 'U':  E is the superdiagonal of A, and A = U**H*D*U;",
       "         = 'L':  E is the subdiagonal of A, and A = L*D*L**H.",
       "         (The two forms are equivalent if A is real.)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n real diagonal elements of the tridiagonal matrix A."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the tridiagonal matrix A",
       "         (see UPLO)."],
     "DF"=>
      ["[in]",
       "         DF is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from",
       "         the factorization computed by ZPTTRF."],
     "EF"=>
      ["[in]",
       "         EF is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the unit bidiagonal",
       "         factor U or L from the factorization computed by ZPTTRF",
       "         (see UPLO)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by ZPTTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j)."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dpteqr"=>
  {"summary"=>
    ["DPTEQR computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric positive definite tridiagonal matrix by first factoring the",
     "matrix using DPTTRF, and then calling DBDSQR to compute the singular",
     "values of the bidiagonal factor.",
     "This routine computes the eigenvalues of the positive definite",
     "tridiagonal matrix to high relative accuracy.  This means that if the",
     "eigenvalues range over many orders of magnitude in size, then the",
     "small eigenvalues and corresponding eigenvectors will be computed",
     "more accurately than, for example, with the standard QR method.",
     "The eigenvectors of a full or band symmetric positive definite matrix",
     "can also be found if DSYTRD, DSPTRD, or DSBTRD has been used to",
     "reduce this matrix to tridiagonal form. (The reduction to tridiagonal",
     "form, however, may preclude the possibility of obtaining high",
     "relative accuracy in the small eigenvalues of the original matrix, if",
     "these eigenvalues range over many orders of magnitude.)"],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'V':  Compute eigenvectors of original symmetric",
       "                 matrix also.  Array Z contains the orthogonal",
       "                 matrix used to reduce the original matrix to",
       "                 tridiagonal form.",
       "         = 'I':  Compute eigenvectors of tridiagonal matrix also."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal",
       "         matrix.",
       "         On normal exit, D contains the eigenvalues, in descending",
       "         order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the orthogonal matrix used in the",
       "         reduction to tridiagonal form.",
       "         On exit, if COMPZ = 'V', the orthonormal eigenvectors of the",
       "         original symmetric matrix;",
       "         if COMPZ = 'I', the orthonormal eigenvectors of the",
       "         tridiagonal matrix.",
       "         If INFO > 0 on exit, Z contains the eigenvectors associated",
       "         with only the stored eigenvalues.",
       "         If  COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         COMPZ = 'V' or 'I', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, and i is:",
       "               <= N  the Cholesky factorization of the matrix could",
       "                     not be performed because the i-th principal minor",
       "                     was not positive definite.",
       "               > N   the SVD algorithm failed to converge;",
       "                     if INFO = N+i, i off-diagonal elements of the",
       "                     bidiagonal factor did not converge to zero."]}},
 "zhetrs_rook"=>
  {"summary"=>
    ["ZHETRS_ROOK solves a system of linear equations A*X = B with a complex",
     "Hermitian matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by ZHETRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZHETRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHETRF_ROOK."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "csytf2_rk"=>
  {"summary"=>
    ["CSYTF2_RK computes the factorization of a complex symmetric matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "zlatbs"=>
  {"summary"=>
    ["ZLATBS solves one of the triangular systems",
     "   A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b,",
     "with scaling to prevent overflow, where A is an upper or lower",
     "triangular band matrix.  Here A**T denotes the transpose of A, x and b",
     "are n-element vectors, and s is a scaling factor, usually less than",
     "or equal to 1, chosen so that the components of x will be less than",
     "the overflow threshold.  If the unscaled problem will not cause",
     "overflow, the Level 2 BLAS routine ZTBSV is called.  If the matrix A",
     "is singular (A(j,j) = 0 for some j), then s is set to 0 and a",
     "non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b     (No transpose)",
       "         = 'T':  Solve A**T * x = s*b  (Transpose)",
       "         = 'C':  Solve A**H * x = s*b  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of subdiagonals or superdiagonals in the",
       "         triangular matrix A.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first KD+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is DOUBLE PRECISION array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "zstegr"=>
  {"summary"=>
    ["ZSTEGR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix T. Any such unreduced matrix has",
     "a well defined set of pairwise different real eigenvalues, the corresponding",
     "real eigenvectors are pairwise orthogonal.",
     "The spectrum may be computed either completely or partially by specifying",
     "either an interval (VL,VU] or a range of indices IL:IU for the desired",
     "eigenvalues.",
     "ZSTEGR is a compatibility wrapper around the improved ZSTEMR routine.",
     "See DSTEMR for further details.",
     "One important change is that the ABSTOL parameter no longer provides any",
     "benefit and hence is no longer used.",
     "Note : ZSTEGR and ZSTEMR work only on machines which follow",
     "IEEE-754 floating-point standard in their handling of infinities and",
     "NaNs.  Normal execution may create these exceptiona values and hence",
     "may abort due to a floating point exception in environments which",
     "do not conform to the IEEE-754 standard."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal matrix",
       "         T. On exit, D is overwritten."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the tridiagonal",
       "         matrix T in elements 1 to N-1 of E. E(N) need not be set on",
       "         input, but is used internally as workspace.",
       "         On exit, E is overwritten."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         Unused.  Was the absolute error tolerance for the",
       "         eigenvalues/eigenvectors in previous versions."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', and if INFO = 0, then the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix T",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used.",
       "         Supplying N columns is always safe."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', then LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER ARRAY, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th computed eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is relevant in the case when the matrix",
       "         is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal",
       "         (and minimal) LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,18*N)",
       "         if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (LIWORK)",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N)",
       "         if the eigenvectors are desired, and LIWORK >= max(1,8*N)",
       "         if only the eigenvalues are to be computed.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = 1X, internal error in DLARRE,",
       "               if INFO = 2X, internal error in ZLARRV.",
       "               Here, the digit X = ABS( IINFO ) < 10, where IINFO is",
       "               the nonzero error code returned by DLARRE or",
       "               ZLARRV, respectively."]}},
 "spftrs"=>
  {"summary"=>
    ["SPFTRS solves a system of linear equations A*X = B with a symmetric",
     "positive definite matrix A using the Cholesky factorization",
     "A = U**T*U or A = L*L**T computed by SPFTRF."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'T':  The Transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of RFP A is stored;",
       "         = 'L':  Lower triangle of RFP A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension ( N*(N+1)/2 )",
       "         The triangular factor U or L from the Cholesky factorization",
       "         of RFP A = U**H*U or RFP A = L*L**T, as computed by SPFTRF.",
       "         See note below for more details about RFP A."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cpotrf"=>
  {"summary"=>
    ["CPOTRF computes the Cholesky factorization of a complex Hermitian",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the block version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**H*U or A = L*L**H."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "cspr"=>
  {"summary"=>
    ["CSPR    performs the symmetric rank 1 operation",
     "   A := alpha*x*x**H + A,",
     "where alpha is a complex scalar, x is an n element vector and A is an",
     "n by n symmetric matrix, supplied in packed form."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the matrix A is supplied in the packed",
       "          array AP as follows:",
       "             UPLO = 'U' or 'u'   The upper triangular part of A is",
       "                                 supplied in AP.",
       "             UPLO = 'L' or 'l'   The lower triangular part of A is",
       "                                 supplied in AP.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the order of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCX ) ).",
       "          Before entry, the incremented array X must contain the N-",
       "          element vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension at least",
       "          ( ( N*( N + 1 ) )/2 ).",
       "          Before entry, with  UPLO = 'U' or 'u', the array AP must",
       "          contain the upper triangular part of the symmetric matrix",
       "          packed sequentially, column by column, so that AP( 1 )",
       "          contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 )",
       "          and a( 2, 2 ) respectively, and so on. On exit, the array",
       "          AP is overwritten by the upper triangular part of the",
       "          updated matrix.",
       "          Before entry, with UPLO = 'L' or 'l', the array AP must",
       "          contain the lower triangular part of the symmetric matrix",
       "          packed sequentially, column by column, so that AP( 1 )",
       "          contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 )",
       "          and a( 3, 1 ) respectively, and so on. On exit, the array",
       "          AP is overwritten by the lower triangular part of the",
       "          updated matrix.",
       "          Note that the imaginary parts of the diagonal elements need",
       "          not be set, they are assumed to be zero, and on exit they",
       "          are set to zero."]}},
 "ztprfb"=>
  {"summary"=>
    ["ZTPRFB applies a complex \"triangular-pentagonal\" block reflector H or its",
     "conjugate transpose H**H to a complex matrix C, which is composed of two",
     "blocks A and B, either from the left or right."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H**H from the Left",
       "         = 'R': apply H or H**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'C': apply H**H (Conjugate transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columns",
       "         = 'R': Rows"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B.",
       "         N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T, i.e. the number of elementary",
       "         reflectors whose product defines the block reflector.",
       "         K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension",
       "                               (LDV,K) if STOREV = 'C'",
       "                               (LDV,M) if STOREV = 'R' and SIDE = 'L'",
       "                               (LDV,N) if STOREV = 'R' and SIDE = 'R'",
       "         The pentagonal matrix V, which contains the elementary reflectors",
       "         H(1), H(2), ..., H(K).  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);",
       "         if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);",
       "         if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension (LDT,K)",
       "         The triangular K-by-K matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.",
       "         LDT >= K."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension",
       "         (LDA,N) if SIDE = 'L' or (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         H*C or H**H*C or C*H or C*H**H.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         H*C or H**H*C or C*H or C*H**H.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension",
       "         (LDWORK,N) if SIDE = 'L',",
       "         (LDWORK,K) if SIDE = 'R'."],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= K;",
       "         if SIDE = 'R', LDWORK >= M."]}},
 "zsytri2x"=>
  {"summary"=>
    ["ZSYTRI2X computes the inverse of a complex symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "ZSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the NNB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by ZSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NNB structure of D",
       "         as determined by ZSYTRF."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (N+NNB+1,NNB+3)"],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "cppsv"=>
  {"summary"=>
    ["CPPSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite matrix stored in",
     "packed format and X and B are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is a lower triangular",
     "matrix.  The factored form of A is then used to solve the system of",
     "equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**H*U or A = L*L**H, in the same storage",
       "         format as A."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "cgbrfs"=>
  {"summary"=>
    ["CGBRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is banded, and provides",
     "error bounds and backward error estimates for the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The original band matrix A, stored in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX array, dimension (LDAFB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by CGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "         The leading dimension of the array AFB.  LDAFB >= 2*KL*KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from CGBTRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by CGBTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zsyswapr"=>
  {"summary"=>
    ["ZSYSWAPR applies an elementary permutation on the rows and the columns of",
     "a symmetric matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by ZSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "I1"=>
      ["[in]",
       "         I1 is INTEGER",
       "         Index of the first row to swap"],
     "I2"=>
      ["[in]",
       "         I2 is INTEGER",
       "         Index of the second row to swap"]}},
 "dlalsa"=>
  {"summary"=>
    ["DLALSA is an itermediate step in solving the least squares problem",
     "by computing the SVD of the coefficient matrix in compact form (The",
     "singular vectors are computed as products of simple orthorgonal",
     "matrices.).",
     "If ICOMPQ = 0, DLALSA applies the inverse of the left singular vector",
     "matrix of an upper bidiagonal matrix to the right hand side; and if",
     "ICOMPQ = 1, DLALSA applies the right singular vector matrix to the",
     "right hand side. The singular vector matrices were generated in",
     "compact form by DLALSA."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether the left or the right singular vector",
       "        matrix is involved.",
       "        = 0: Left singular vector matrix",
       "        = 1: Right singular vector matrix"],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        The maximum size of the subproblems at the bottom of the",
       "        computation tree."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The row and column dimensions of the upper bidiagonal matrix."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B and BX. NRHS must be at least 1."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension ( LDB, NRHS )",
       "        On input, B contains the right hand sides of the least",
       "        squares problem in rows 1 through M.",
       "        On output, B contains the solution X in rows 1 through N."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B in the calling subprogram.",
       "        LDB must be at least max(1,MAX( M, N ) )."],
     "BX"=>
      ["[out]",
       "         BX is DOUBLE PRECISION array, dimension ( LDBX, NRHS )",
       "        On exit, the result of applying the left or right singular",
       "        vector matrix to B."],
     "LDBX"=>
      ["[in]",
       "         LDBX is INTEGER",
       "        The leading dimension of BX."],
     "U"=>
      ["[in]",
       "         U is DOUBLE PRECISION array, dimension ( LDU, SMLSIZ ).",
       "        On entry, U contains the left singular vector matrices of all",
       "        subproblems at the bottom level."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER, LDU = > N.",
       "        The leading dimension of arrays U, VT, DIFL, DIFR,",
       "        POLES, GIVNUM, and Z."],
     "VT"=>
      ["[in]",
       "         VT is DOUBLE PRECISION array, dimension ( LDU, SMLSIZ+1 ).",
       "        On entry, VT**T contains the right singular vector matrices of",
       "        all subproblems at the bottom level."],
     "K"=>["[in]", "         K is INTEGER array, dimension ( N )."],
     "DIFL"=>
      ["[in]",
       "         DIFL is DOUBLE PRECISION array, dimension ( LDU, NLVL ).",
       "        where NLVL = INT(log_2 (N/(SMLSIZ+1))) + 1."],
     "DIFR"=>
      ["[in]",
       "         DIFR is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, DIFL(*, I) and DIFR(*, 2 * I -1) record",
       "        distances between singular values on the I-th level and",
       "        singular values on the (I -1)-th level, and DIFR(*, 2 * I)",
       "        record the normalizing factors of the right singular vectors",
       "        matrices of subproblems on I-th level."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension ( LDU, NLVL ).",
       "        On entry, Z(1, I) contains the components of the deflation-",
       "        adjusted updating row vector for subproblems on the I-th",
       "        level."],
     "POLES"=>
      ["[in]",
       "         POLES is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, POLES(*, 2 * I -1: 2 * I) contains the new and old",
       "        singular values involved in the secular equations on the I-th",
       "        level."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER array, dimension ( N ).",
       "        On entry, GIVPTR( I ) records the number of Givens",
       "        rotations performed on the I-th problem on the computation",
       "        tree."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 * NLVL ).",
       "        On entry, for each I, GIVCOL(*, 2 * I - 1: 2 * I) records the",
       "        locations of Givens rotations performed on the I-th level on",
       "        the computation tree."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER, LDGCOL = > N.",
       "        The leading dimension of arrays GIVCOL and PERM."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension ( LDGCOL, NLVL ).",
       "        On entry, PERM(*, I) records permutations done on the I-th",
       "        level of the computation tree."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, GIVNUM(*, 2 *I -1 : 2 * I) records the C- and S-",
       "        values of Givens rotations performed on the I-th level on the",
       "        computation tree."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension ( N ).",
       "        On entry, if the I-th subproblem is not square,",
       "        C( I ) contains the C-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension ( N ).",
       "        On entry, if the I-th subproblem is not square,",
       "        S( I ) contains the S-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array.",
       "        The dimension must be at least N."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array.",
       "        The dimension must be at least 3 * N"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dgeqp3"=>
  {"summary"=>
    ["DGEQP3 computes a QR factorization with column pivoting of a",
     "matrix A:  A*P = Q*R  using Level 3 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the upper triangle of the array contains the",
       "         min(M,N)-by-N upper trapezoidal matrix R; the elements below",
       "         the diagonal, together with the array TAU, represent the",
       "         orthogonal matrix Q as a product of min(M,N) elementary",
       "         reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(J).ne.0, the J-th column of A is permuted",
       "         to the front of A*P (a leading column); if JPVT(J)=0,",
       "         the J-th column of A is a free column.",
       "         On exit, if JPVT(J)=K, then the J-th column of A*P was the",
       "         the K-th column of A."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO=0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= 3*N+1.",
       "         For optimal performance LWORK >= 2*N+( N+1 )*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit.",
       "         < 0: if INFO = -i, the i-th argument had an illegal value."]}},
 "zptcon"=>
  {"summary"=>
    ["ZPTCON computes the reciprocal of the condition number (in the",
     "1-norm) of a complex Hermitian positive definite tridiagonal matrix",
     "using the factorization A = L*D*L**H or A = U**H*D*U computed by",
     "ZPTTRF.",
     "Norm(inv(A)) is computed by a direct method, and the reciprocal of",
     "the condition number is computed as",
     "                 RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         factorization of A, as computed by ZPTTRF."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the unit bidiagonal factor",
       "         U or L from the factorization of A, as computed by ZPTTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is the",
       "         1-norm of inv(A) computed in this routine."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dporfsx"=>
  {"summary"=>
    ["   DPORFSX improves the computed solution to a system of linear",
     "   equations when the coefficient matrix is symmetric positive",
     "   definite, and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED and S",
     "   below. In this case, the solution and error bounds returned are",
     "   for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'Y':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(S) * A * diag(S).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "    upper triangular part of A contains the upper triangular part",
       "    of the matrix A, and the strictly lower triangular part of A",
       "    is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "    triangular part of A contains the lower triangular part of",
       "    the matrix A, and the strictly upper triangular part of A is",
       "    not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by DPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "S"=>
      ["[in,out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'Y', A is multiplied on",
       "    the left and right by diag(S).  S is an input argument if FACT =",
       "    'F'; otherwise, S is an output argument.  If FACT = 'F' and EQUED",
       "    = 'Y', each element of S must be positive.  If S is output, each",
       "    element of S is a power of the radix. If S is input, each element",
       "    of S should be a power of the radix to ensure a reliable solution",
       "    and error estimates. Scaling by powers of the radix does not cause",
       "    rounding errors unless the result underflows or overflows.",
       "    Rounding errors during scaling lead to refining with a matrix that",
       "    is not equivalent to the input matrix, producing error estimates",
       "    that may not be reliable."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by DGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is DOUBLE PRECISION array, dimension (NPARAMS)",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0D+0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "dtrexc"=>
  {"summary"=>
    ["DTREXC reorders the real Schur factorization of a real matrix",
     "A = Q*T*Q**T, so that the diagonal block of T with row index IFST is",
     "moved to row ILST.",
     "The real Schur form T is reordered by an orthogonal similarity",
     "transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors",
     "is updated by postmultiplying it with Z.",
     "T must be in Schur canonical form (as returned by DHSEQR), that is,",
     "block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each",
     "2-by-2 diagonal block has its diagonal elements equal and its",
     "off-diagonal elements of opposite sign."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'V':  update the matrix Q of Schur vectors;",
       "         = 'N':  do not update Q."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0.",
       "         If N == 0 arguments ILST and IFST may be any value."],
     "T"=>
      ["[in,out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         On entry, the upper quasi-triangular matrix T, in Schur",
       "         Schur canonical form.",
       "         On exit, the reordered upper quasi-triangular matrix, again",
       "         in Schur canonical form."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         On entry, if COMPQ = 'V', the matrix Q of Schur vectors.",
       "         On exit, if COMPQ = 'V', Q has been postmultiplied by the",
       "         orthogonal transformation matrix Z which reorders T.",
       "         If COMPQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= 1, and if",
       "         COMPQ = 'V', LDQ >= max(1,N)."],
     "IFST"=>["[in,out]", "         IFST is INTEGER"],
     "ILST"=>
      ["[in,out]",
       "         ILST is INTEGER",
       "         Specify the reordering of the diagonal blocks of T.",
       "         The block with row index IFST is moved to row ILST, by a",
       "         sequence of transpositions between adjacent blocks.",
       "         On exit, if IFST pointed on entry to the second row of a",
       "         2-by-2 block, it is changed to point to the first row; ILST",
       "         always points to the first row of the block in its final",
       "         position (which may differ from its input value by +1 or -1).",
       "         1 <= IFST <= N; 1 <= ILST <= N."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         = 1:  two adjacent blocks were too close to swap (the problem",
       "               is very ill-conditioned); T may have been partially",
       "               reordered, and ILST points to the first row of the",
       "               current position of the block being moved."]}},
 "slarrk"=>
  {"summary"=>
    ["SLARRK computes one eigenvalue of a symmetric tridiagonal",
     "matrix T to suitable accuracy. This is an auxiliary code to be",
     "called from SSTEMR.",
     "To avoid overflow, the matrix must be scaled so that its",
     "largest element is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest",
     "accuracy, it should not be much smaller than that.",
     "See W. Kahan \"Accurate Eigenvalues of a Symmetric Tridiagonal",
     "Matrix\", Report CS41, Computer Science Dept., Stanford",
     "University, July 21, 1966."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix T.  N >= 0."],
     "IW"=>
      ["[in]",
       "         IW is INTEGER",
       "         The index of the eigenvalues to be returned."],
     "GL"=>["[in]", "         GL is REAL"],
     "GU"=>
      ["[in]",
       "         GU is REAL",
       "         An upper and a lower bound on the eigenvalue."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix T."],
     "E2"=>
      ["[in]",
       "         E2 is REAL array, dimension (N-1)",
       "         The (n-1) squared off-diagonal elements of the tridiagonal matrix T."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "         The minimum pivot allowed in the Sturm sequence for T."],
     "RELTOL"=>
      ["[in]",
       "         RELTOL is REAL",
       "         The minimum relative width of an interval.  When an interval",
       "         is narrower than RELTOL times the larger (in",
       "         magnitude) endpoint, then it is considered to be",
       "         sufficiently small, i.e., converged.  Note: this should",
       "         always be at least radix*machine epsilon."],
     "W"=>["[out]", "         W is REAL"],
     "WERR"=>
      ["[out]",
       "         WERR is REAL",
       "         The error bound on the corresponding eigenvalue approximation",
       "         in W."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:       Eigenvalue converged",
       "         = -1:      Eigenvalue did NOT converge"]}},
 "dtgex2"=>
  {"summary"=>
    ["DTGEX2 swaps adjacent diagonal blocks (A11, B11) and (A22, B22)",
     "of size 1-by-1 or 2-by-2 in an upper (quasi) triangular matrix pair",
     "(A, B) by an orthogonal equivalence transformation.",
     "(A, B) must be in generalized real Schur canonical form (as returned",
     "by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2",
     "diagonal blocks. B is upper triangular.",
     "Optionally, the matrices Q and Z of generalized Schur vectors are",
     "updated.",
     "       Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T",
     "       Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T"],
   "param"=>
    {"WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimensions (LDA,N)",
       "         On entry, the matrix A in the pair (A, B).",
       "         On exit, the updated matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimensions (LDB,N)",
       "         On entry, the matrix B in the pair (A, B).",
       "         On exit, the updated matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         On entry, if WANTQ = .TRUE., the orthogonal matrix Q.",
       "         On exit, the updated matrix Q.",
       "         Not referenced if WANTQ = .FALSE.."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= 1.",
       "         If WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ,N)",
       "         On entry, if WANTZ =.TRUE., the orthogonal matrix Z.",
       "         On exit, the updated matrix Z.",
       "         Not referenced if WANTZ = .FALSE.."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1.",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The index to the first block (A11, B11). 1 <= J1 <= N."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         The order of the first block (A11, B11). N1 = 0, 1 or 2."],
     "N2"=>
      ["[in]",
       "         N2 is INTEGER",
       "         The order of the second block (A22, B22). N2 = 0, 1 or 2."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >=  MAX( 1, N*(N2+N1), (N2+N1)*(N2+N1)*2 )"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "           =0: Successful exit",
       "           >0: If INFO = 1, the transformed matrix (A, B) would be",
       "               too far from generalized Schur form; the blocks are",
       "               not swapped and (A, B) and (Q, Z) are unchanged.",
       "               The problem of swapping is too ill-conditioned.",
       "           <0: If INFO = -16: LWORK is too small. Appropriate value",
       "               for LWORK is returned in WORK(1)."]}},
 "zlaqsy"=>
  {"summary"=>
    ["ZLAQSY equilibrates a symmetric matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if EQUED = 'Y', the equilibrated matrix:",
       "         diag(S) * A * diag(S)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is DOUBLE PRECISION",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "slargv"=>
  {"summary"=>
    ["SLARGV generates a vector of real plane rotations, determined by",
     "elements of the real vectors x and y. For i = 1,2,...,n",
     "   (  c(i)  s(i) ) ( x(i) ) = ( a(i) )",
     "   ( -s(i)  c(i) ) ( y(i) ) = (   0  )"],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be generated."],
     "X"=>
      ["[in,out]",
       "         X is REAL array,",
       "                        dimension (1+(N-1)*INCX)",
       "         On entry, the vector x.",
       "         On exit, x(i) is overwritten by a(i), for i = 1,...,n."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array,",
       "                        dimension (1+(N-1)*INCY)",
       "         On entry, the vector y.",
       "         On exit, the sines of the plane rotations."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between elements of Y. INCY > 0."],
     "C"=>
      ["[out]",
       "         C is REAL array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C. INCC > 0."]}},
 "stgexc"=>
  {"summary"=>
    ["STGEXC reorders the generalized real Schur decomposition of a real",
     "matrix pair (A,B) using an orthogonal equivalence transformation",
     "               (A, B) = Q * (A, B) * Z**T,",
     "so that the diagonal block of (A, B) with row index IFST is moved",
     "to row ILST.",
     "(A, B) must be in generalized real Schur canonical form (as returned",
     "by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2",
     "diagonal blocks. B is upper triangular.",
     "Optionally, the matrices Q and Z of generalized Schur vectors are",
     "updated.",
     "       Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T",
     "       Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T"],
   "param"=>
    {"WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the matrix A in generalized real Schur canonical",
       "         form.",
       "         On exit, the updated matrix A, again in generalized",
       "         real Schur canonical form."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the matrix B in generalized real Schur canonical",
       "         form (A,B).",
       "         On exit, the updated matrix B, again in generalized",
       "         real Schur canonical form (A,B)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDZ,N)",
       "         On entry, if WANTQ = .TRUE., the orthogonal matrix Q.",
       "         On exit, the updated matrix Q.",
       "         If WANTQ = .FALSE., Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= 1.",
       "         If WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ,N)",
       "         On entry, if WANTZ = .TRUE., the orthogonal matrix Z.",
       "         On exit, the updated matrix Z.",
       "         If WANTZ = .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1.",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "IFST"=>["[in,out]", "         IFST is INTEGER"],
     "ILST"=>
      ["[in,out]",
       "         ILST is INTEGER",
       "         Specify the reordering of the diagonal blocks of (A, B).",
       "         The block with row index IFST is moved to row ILST, by a",
       "         sequence of swapping between adjacent blocks.",
       "         On exit, if IFST pointed on entry to the second row of",
       "         a 2-by-2 block, it is changed to point to the first row;",
       "         ILST always points to the first row of the block in its",
       "         final position (which may differ from its input value by",
       "         +1 or -1). 1 <= IFST, ILST <= N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= 1 when N <= 1, otherwise LWORK >= 4*N + 16.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          =0:  successful exit.",
       "          <0:  if INFO = -i, the i-th argument had an illegal value.",
       "          =1:  The transformed matrix pair (A, B) would be too far",
       "               from generalized Schur form; the problem is ill-",
       "               conditioned. (A, B) may have been partially reordered,",
       "               and ILST points to the first row of the current",
       "               position of the block being moved."]}},
 "zgtts2"=>
  {"summary"=>
    ["ZGTTS2 solves one of the systems of equations",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B,",
     "with a tridiagonal matrix A using the LU factorization computed",
     "by ZGTTRF."],
   "param"=>
    {"ITRANS"=>
      ["[in]",
       "         ITRANS is INTEGER",
       "         Specifies the form of the system of equations.",
       "         = 0:  A * X = B     (No transpose)",
       "         = 1:  A**T * X = B  (Transpose)",
       "         = 2:  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A."],
     "D"=>
      ["[in]",
       "         D is COMPLEX*16 array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) elements of the first super-diagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is COMPLEX*16 array, dimension (N-2)",
       "         The (n-2) elements of the second super-diagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the matrix of right hand side vectors B.",
       "         On exit, B is overwritten by the solution vectors X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."]}},
 "zheev_2stage"=>
  {"summary"=>
    ["ZHEEV_2STAGE computes all eigenvalues and, optionally, eigenvectors of a",
     "complex Hermitian matrix A using the 2stage technique for",
     "the reduction to tridiagonal."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "slacon"=>
  {"summary"=>
    ["SLACON estimates the 1-norm of a square, real matrix A.",
     "Reverse communication is used for evaluating matrix-vector products."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The order of the matrix.  N >= 1."],
     "V"=>
      ["[out]",
       "         V is REAL array, dimension (N)",
       "        On the final return, V = A*W,  where  EST = norm(V)/norm(W)",
       "        (W is not returned)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (N)",
       "        On an intermediate return, X should be overwritten by",
       "              A * X,   if KASE=1,",
       "              A**T * X,  if KASE=2,",
       "        and SLACON must be re-called with all the other parameters",
       "        unchanged."],
     "ISGN"=>["[out]", "         ISGN is INTEGER array, dimension (N)"],
     "EST"=>
      ["[in,out]",
       "         EST is REAL",
       "        On entry with KASE = 1 or 2 and JUMP = 3, EST should be",
       "        unchanged from the previous call to SLACON.",
       "        On exit, EST is an estimate (a lower bound) for norm(A)."],
     "KASE"=>
      ["[in,out]",
       "         KASE is INTEGER",
       "        On the initial call to SLACON, KASE should be 0.",
       "        On an intermediate return, KASE will be 1 or 2, indicating",
       "        whether X should be overwritten by A * X  or A**T * X.",
       "        On the final return from SLACON, KASE will again be 0."]}},
 "zheevr_2stage"=>
  {"summary"=>
    ["ZHEEVR_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues.",
     "ZHEEVR_2STAGE first reduces the matrix A to tridiagonal form T with a call",
     "to ZHETRD.  Then, whenever possible, ZHEEVR_2STAGE calls ZSTEMR to compute",
     "eigenspectrum using Relatively Robust Representations.  ZSTEMR",
     "computes eigenvalues by the dqds algorithm, while orthogonal",
     "eigenvectors are computed from various \"good\" L D L^T representations",
     "(also known as Relatively Robust Representations). Gram-Schmidt",
     "orthogonalization is avoided as far as possible. More specifically,",
     "the various steps of the algorithm are as follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "The desired accuracy of the output can be specified by the input",
     "parameter ABSTOL.",
     "For more details, see DSTEMR's documentation and:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Note 1 : ZHEEVR_2STAGE calls ZSTEMR when the full spectrum is requested",
     "on machines which conform to the ieee-754 floating point standard.",
     "ZHEEVR_2STAGE calls DSTEBZ and ZSTEIN on non-ieee machines and",
     "when partial spectrum requests are made.",
     "Normal execution of ZSTEMR may create NaNs and infinities and",
     "hence may abort due to a floating point exception in environments",
     "which do not handle NaNs and infinities in the ieee standard default",
     "manner."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found.",
       "         For RANGE = 'V' or 'I' and IU - IL < N - 1, DSTEBZ and",
       "         ZSTEIN are called"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3.",
       "         If high relative accuracy is important, set ABSTOL to",
       "         DLAMCH( 'Safe minimum' ).  Doing so will guarantee that",
       "         eigenvalues are computed to high relative accuracy when",
       "         possible in future releases.  The current code does not",
       "         make any guarantees about high relative accuracy, but",
       "         furutre releases will. See J. Barlow and J. Demmel,",
       "         \"Computing Accurate Eigensystems of Scaled Diagonally",
       "         Dominant Matrices\", LAPACK Working Note #7, for a discussion",
       "         of which matrices define their eigenvalues to high relative",
       "         accuracy."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is an output of ZSTEMR (tridiagonal",
       "         matrix). The support of the eigenvectors of A is typically ",
       "         1:N because of the unitary transformations applied by ZUNMTR.",
       "         Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1"],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, 26*N, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal",
       "         (and minimal) LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The length of the array RWORK.  LRWORK >= max(1,24*N).",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal",
       "         (and minimal) LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  Internal error"]}},
 "dlantp"=>
  {"summary"=>
    ["DLANTP  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "triangular matrix A, supplied in packed form.",
     "   DLANTP = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANTP as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, DLANTP is",
       "         set to zero."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         Note that when DIAG = 'U', the elements of the array AP",
       "         corresponding to the diagonal elements of the matrix A are",
       "         not referenced, but are assumed to be one."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "sggev3"=>
  {"summary"=>
    ["SGGEV3 computes for a pair of N-by-N real nonsymmetric matrices (A,B)",
     "the generalized eigenvalues, and optionally, the left and/or right",
     "generalized eigenvectors.",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right eigenvector v(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 A * v(j) = lambda(j) * B * v(j).",
     "The left eigenvector u(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 u(j)**H * A  = lambda(j) * u(j)**H * B .",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHAR"=>["[out]", "         ALPHAR is REAL array, dimension (N)"],
     "ALPHAI"=>["[out]", "         ALPHAI is REAL array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  If ALPHAI(j) is zero, then",
       "         the j-th eigenvalue is real; if positive, then the j-th and",
       "         (j+1)-st eigenvalues are a complex conjugate pair, with",
       "         ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio",
       "         alpha/beta.  However, ALPHAR and ALPHAI will be always less",
       "         than and usually comparable with norm(A) in magnitude, and",
       "         BETA always less than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is REAL array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         u(j) = VL(:,j), the j-th column of VL. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         u(j) = VL(:,j)+i*VL(:,j+1) and u(j+1) = VL(:,j)-i*VL(:,j+1).",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part)+abs(imag. part)=1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is REAL array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         v(j) = VR(:,j), the j-th column of VR. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1).",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part)+abs(imag. part)=1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHAR(j), ALPHAI(j), and BETA(j)",
       "               should be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in SHGEQZ.",
       "               =N+2: error return from STGEVC."]}},
 "cheevr_2stage"=>
  {"summary"=>
    ["CHEEVR_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues.",
     "CHEEVR_2STAGE first reduces the matrix A to tridiagonal form T with a call",
     "to CHETRD.  Then, whenever possible, CHEEVR_2STAGE calls CSTEMR to compute",
     "eigenspectrum using Relatively Robust Representations.  CSTEMR",
     "computes eigenvalues by the dqds algorithm, while orthogonal",
     "eigenvectors are computed from various \"good\" L D L^T representations",
     "(also known as Relatively Robust Representations). Gram-Schmidt",
     "orthogonalization is avoided as far as possible. More specifically,",
     "the various steps of the algorithm are as follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "The desired accuracy of the output can be specified by the input",
     "parameter ABSTOL.",
     "For more details, see DSTEMR's documentation and:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Note 1 : CHEEVR_2STAGE calls CSTEMR when the full spectrum is requested",
     "on machines which conform to the ieee-754 floating point standard.",
     "CHEEVR_2STAGE calls SSTEBZ and CSTEIN on non-ieee machines and",
     "when partial spectrum requests are made.",
     "Normal execution of CSTEMR may create NaNs and infinities and",
     "hence may abort due to a floating point exception in environments",
     "which do not handle NaNs and infinities in the ieee standard default",
     "manner."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found.",
       "         For RANGE = 'V' or 'I' and IU - IL < N - 1, SSTEBZ and",
       "         CSTEIN are called"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3.",
       "         If high relative accuracy is important, set ABSTOL to",
       "         SLAMCH( 'Safe minimum' ).  Doing so will guarantee that",
       "         eigenvalues are computed to high relative accuracy when",
       "         possible in future releases.  The current code does not",
       "         make any guarantees about high relative accuracy, but",
       "         furutre releases will. See J. Barlow and J. Demmel,",
       "         \"Computing Accurate Eigensystems of Scaled Diagonally",
       "         Dominant Matrices\", LAPACK Working Note #7, for a discussion",
       "         of which matrices define their eigenvalues to high relative",
       "         accuracy."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is an output of CSTEMR (tridiagonal",
       "         matrix). The support of the eigenvectors of A is typically ",
       "         1:N because of the unitary transformations applied by CUNMTR.",
       "         Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1"],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, 26*N, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal",
       "         (and minimal) LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The length of the array RWORK.  LRWORK >= max(1,24*N).",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal",
       "         (and minimal) LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  Internal error"]}},
 "clag2z"=>
  {"summary"=>
    ["CLAG2Z converts a COMPLEX matrix, SA, to a COMPLEX*16 matrix, A.",
     "Note that while it is possible to overflow while converting",
     "from double to single, it is not possible to overflow when",
     "converting from single to double.",
     "This is an auxiliary routine so there is no argument checking."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of lines of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "SA"=>
      ["[in]",
       "         SA is COMPLEX array, dimension (LDSA,N)",
       "         On entry, the M-by-N coefficient matrix SA."],
     "LDSA"=>
      ["[in]",
       "         LDSA is INTEGER",
       "         The leading dimension of the array SA.  LDSA >= max(1,M)."],
     "A"=>
      ["[out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On exit, the M-by-N coefficient matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit"]}},
 "dlags2"=>
  {"summary"=>
    ["DLAGS2 computes 2-by-2 orthogonal matrices U, V and Q, such",
     "that if ( UPPER ) then",
     "          U**T *A*Q = U**T *( A1 A2 )*Q = ( x  0  )",
     "                            ( 0  A3 )     ( x  x  )",
     "and",
     "          V**T*B*Q = V**T *( B1 B2 )*Q = ( x  0  )",
     "                           ( 0  B3 )     ( x  x  )",
     "or if ( .NOT.UPPER ) then",
     "          U**T *A*Q = U**T *( A1 0  )*Q = ( x  x  )",
     "                            ( A2 A3 )     ( 0  x  )",
     "and",
     "          V**T*B*Q = V**T*( B1 0  )*Q = ( x  x  )",
     "                          ( B2 B3 )     ( 0  x  )",
     "The rows of the transformed A and B are parallel, where",
     "  U = (  CSU  SNU ), V = (  CSV SNV ), Q = (  CSQ   SNQ )",
     "      ( -SNU  CSU )      ( -SNV CSV )      ( -SNQ   CSQ )",
     "Z**T denotes the transpose of Z."],
   "param"=>
    {"UPPER"=>
      ["[in]",
       "         UPPER is LOGICAL",
       "         = .TRUE.: the input matrices A and B are upper triangular.",
       "         = .FALSE.: the input matrices A and B are lower triangular."],
     "A1"=>["[in]", "         A1 is DOUBLE PRECISION"],
     "A2"=>["[in]", "         A2 is DOUBLE PRECISION"],
     "A3"=>
      ["[in]",
       "         A3 is DOUBLE PRECISION",
       "         On entry, A1, A2 and A3 are elements of the input 2-by-2",
       "         upper (lower) triangular matrix A."],
     "B1"=>["[in]", "         B1 is DOUBLE PRECISION"],
     "B2"=>["[in]", "         B2 is DOUBLE PRECISION"],
     "B3"=>
      ["[in]",
       "         B3 is DOUBLE PRECISION",
       "         On entry, B1, B2 and B3 are elements of the input 2-by-2",
       "         upper (lower) triangular matrix B."],
     "CSU"=>["[out]", "         CSU is DOUBLE PRECISION"],
     "SNU"=>
      ["[out]",
       "         SNU is DOUBLE PRECISION",
       "         The desired orthogonal matrix U."],
     "CSV"=>["[out]", "         CSV is DOUBLE PRECISION"],
     "SNV"=>
      ["[out]",
       "         SNV is DOUBLE PRECISION",
       "         The desired orthogonal matrix V."],
     "CSQ"=>["[out]", "         CSQ is DOUBLE PRECISION"],
     "SNQ"=>
      ["[out]",
       "         SNQ is DOUBLE PRECISION",
       "         The desired orthogonal matrix Q."]}},
 "zla_gbamv"=>
  {"summary"=>
    ["ZLA_GBAMV  performs one of the matrix-vector operations",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "   or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "m by n matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is INTEGER",
       "          On entry, TRANS specifies the operation to be performed as",
       "          follows:",
       "            BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)",
       "            BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "            BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of the matrix A.",
       "          M must be at least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "          The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "          The number of superdiagonals within the band of A.  KU >= 0."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array of DIMENSION ( LDAB, n )",
       "          Before entry, the leading m by n part of the array AB must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "          On entry, LDAB specifies the first dimension of AB as declared",
       "          in the calling (sub) program. LDAB must be at least",
       "          max( 1, m ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension",
       "          ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit.",
       " Level 2 Blas routine."]}},
 "sgttrf"=>
  {"summary"=>
    ["SGTTRF computes an LU factorization of a real tridiagonal matrix A",
     "using elimination with partial pivoting and row interchanges.",
     "The factorization has the form",
     "   A = L * U",
     "where L is a product of permutation and unit lower bidiagonal",
     "matrices and U is upper triangular with nonzeros in only the main",
     "diagonal and first two superdiagonals."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "DL"=>
      ["[in,out]",
       "         DL is REAL array, dimension (N-1)",
       "         On entry, DL must contain the (n-1) sub-diagonal elements of",
       "         A.",
       "         On exit, DL is overwritten by the (n-1) multipliers that",
       "         define the matrix L from the LU factorization of A."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, D must contain the diagonal elements of A.",
       "         On exit, D is overwritten by the n diagonal elements of the",
       "         upper triangular matrix U from the LU factorization of A."],
     "DU"=>
      ["[in,out]",
       "         DU is REAL array, dimension (N-1)",
       "         On entry, DU must contain the (n-1) super-diagonal elements",
       "         of A.",
       "         On exit, DU is overwritten by the (n-1) elements of the first",
       "         super-diagonal of U."],
     "DU2"=>
      ["[out]",
       "         DU2 is REAL array, dimension (N-2)",
       "         On exit, DU2 is overwritten by the (n-2) elements of the",
       "         second super-diagonal of U."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value",
       "         > 0:  if INFO = k, U(k,k) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "sorgqr"=>
  {"summary"=>
    ["SORGQR generates an M-by-N real matrix Q with orthonormal columns,",
     "which is defined as the first N columns of a product of K elementary",
     "reflectors of order M",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by SGEQRF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the i-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by SGEQRF in the first k columns of its array",
       "         argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGEQRF."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "dtrti2"=>
  {"summary"=>
    ["DTRTI2 computes the inverse of a real upper or lower triangular",
     "matrix.",
     "This is the Level 2 BLAS version of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading n by n upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced.  If DIAG = 'U', the",
       "         diagonal elements of A are also not referenced and are",
       "         assumed to be 1.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "cgees"=>
  {"summary"=>
    ["CGEES computes for an N-by-N complex nonsymmetric matrix A, the",
     "eigenvalues, the Schur form T, and, optionally, the matrix of Schur",
     "vectors Z.  This gives the Schur factorization A = Z*T*(Z**H).",
     "Optionally, it also orders the eigenvalues on the diagonal of the",
     "Schur form so that selected eigenvalues are at the top left.",
     "The leading columns of Z then form an orthonormal basis for the",
     "invariant subspace corresponding to the selected eigenvalues.",
     "A complex matrix is in Schur form if it is upper triangular."],
   "param"=>
    {"JOBVS"=>
      ["[in]",
       "         JOBVS is CHARACTER*1",
       "         = 'N': Schur vectors are not computed;",
       "         = 'V': Schur vectors are computed."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the Schur form.",
       "         = 'N': Eigenvalues are not ordered:",
       "         = 'S': Eigenvalues are ordered (see SELECT)."],
     "SELECT"=>
      ["[in]",
       "         SELECT is a LOGICAL FUNCTION of one COMPLEX argument",
       "         SELECT must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'S', SELECT is used to select eigenvalues to order",
       "         to the top left of the Schur form.",
       "         IF SORT = 'N', SELECT is not referenced.",
       "         The eigenvalue W(j) is selected if SELECT(W(j)) is true."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten by its Schur form T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues for which",
       "                        SELECT is true."],
     "W"=>
      ["[out]",
       "         W is COMPLEX array, dimension (N)",
       "         W contains the computed eigenvalues, in the same order that",
       "         they appear on the diagonal of the output Schur form T."],
     "VS"=>
      ["[out]",
       "         VS is COMPLEX array, dimension (LDVS,N)",
       "         If JOBVS = 'V', VS contains the unitary matrix Z of Schur",
       "         vectors.",
       "         If JOBVS = 'N', VS is not referenced."],
     "LDVS"=>
      ["[in]",
       "         LDVS is INTEGER",
       "         The leading dimension of the array VS.  LDVS >= 1; if",
       "         JOBVS = 'V', LDVS >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,2*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value.",
       "         > 0: if INFO = i, and i is",
       "              <= N:  the QR algorithm failed to compute all the",
       "                     eigenvalues; elements 1:ILO-1 and i+1:N of W",
       "                     contain those eigenvalues which have converged;",
       "                     if JOBVS = 'V', VS contains the matrix which",
       "                     reduces A to its partially converged Schur form.",
       "              = N+1: the eigenvalues could not be reordered because",
       "                     some eigenvalues were too close to separate (the",
       "                     problem is very ill-conditioned);",
       "              = N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Schur form no longer satisfy",
       "                     SELECT = .TRUE..  This could also be caused by",
       "                     underflow due to scaling."]}},
 "cla_syrcond_x"=>
  {"summary"=>
    ["   CLA_SYRCOND_X Computes the infinity norm condition number of",
     "   op(A) * diag(X) where X is a COMPLEX vector."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by CSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by CSYTRF."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension (N)",
       "    The vector X in the formula op(A) * diag(X)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is REAL array, dimension (N).",
       "    Workspace."]}},
 "chptri"=>
  {"summary"=>
    ["CHPTRI computes the inverse of a complex Hermitian indefinite matrix",
     "A in packed storage using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by CHPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CHPTRF,",
       "         stored as a packed triangular matrix.",
       "         On exit, if INFO = 0, the (Hermitian) inverse of the original",
       "         matrix, stored as a packed triangular matrix. The j-th column",
       "         of inv(A) is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;",
       "         if UPLO = 'L',",
       "            AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHPTRF."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "zlapmt"=>
  {"summary"=>
    ["ZLAPMT rearranges the columns of the M by N matrix X as specified",
     "by the permutation K(1),K(2),...,K(N) of the integers 1,...,N.",
     "If FORWRD = .TRUE.,  forward permutation:",
     "     X(*,K(J)) is moved X(*,J) for J = 1,2,...,N.",
     "If FORWRD = .FALSE., backward permutation:",
     "     X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N."],
   "param"=>
    {"FORWRD"=>
      ["[in]",
       "         FORWRD is LOGICAL",
       "         = .TRUE., forward permutation",
       "         = .FALSE., backward permutation"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix X. N >= 0."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,N)",
       "         On entry, the M by N matrix X.",
       "         On exit, X contains the permuted matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X, LDX >= MAX(1,M)."],
     "K"=>
      ["[in,out]",
       "         K is INTEGER array, dimension (N)",
       "         On entry, K contains the permutation vector. K is used as",
       "         internal workspace, but reset to its original value on",
       "         output."]}},
 "zlarzb"=>
  {"summary"=>
    ["ZLARZB applies a complex block reflector H or its transpose H**H",
     "to a complex distributed M-by-N  C from the left or the right.",
     "Currently, only STOREV = 'R' and DIRECT = 'B' are supported."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H**H from the Left",
       "         = 'R': apply H or H**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'C': apply H**H (Conjugate transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columnwise                        (not supported yet)",
       "         = 'R': Rowwise"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T (= the number of elementary",
       "         reflectors whose product defines the block reflector)."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix V containing the",
       "         meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension (LDV,NV).",
       "         If STOREV = 'C', NV = K; if STOREV = 'R', NV = L."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= L; if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension (LDT,K)",
       "         The triangular K-by-K matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by H*C or H**H*C or C*H or C*H**H."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX*16 array, dimension (LDWORK,K)"],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= max(1,N);",
       "         if SIDE = 'R', LDWORK >= max(1,M)."]}},
 "dgsvj0"=>
  {"summary"=>
    ["DGSVJ0 is called from DGESVJ as a pre-processor and that is its main",
     "purpose. It applies Jacobi rotations in the same way as DGESVJ does, but",
     "it does not check convergence (stopping criterion). Few tuning",
     "parameters (marked by [TP]) are available for the implementer."],
   "param"=>
    {"JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether the output from this procedure is used",
       "         to compute the matrix V:",
       "         = 'V': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the N-by-N array V.",
       "               (See the description of V.)",
       "         = 'A': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the MV-by-N array V.",
       "               (See the descriptions of MV and V.)",
       "         = 'N': the Jacobi rotations are not accumulated."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, M-by-N matrix A, such that A*diag(D) represents",
       "         the input matrix.",
       "         On exit,",
       "         A_onexit * D_onexit represents the input matrix A*diag(D)",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of D, TOL and NSWEEP.)"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The array D accumulates the scaling factors from the fast scaled",
       "         Jacobi rotations.",
       "         On entry, A*diag(D) represents the input matrix.",
       "         On exit, A_onexit*diag(D_onexit) represents the input matrix",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of A, TOL and NSWEEP.)"],
     "SVA"=>
      ["[in,out]",
       "         SVA is DOUBLE PRECISION array, dimension (N)",
       "         On entry, SVA contains the Euclidean norms of the columns of",
       "         the matrix A*diag(D).",
       "         On exit, SVA contains the Euclidean norms of the columns of",
       "         the matrix onexit*diag(D_onexit)."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then MV is not referenced."],
     "V"=>
      ["[in,out]",
       "         V is DOUBLE PRECISION array, dimension (LDV,N)",
       "         If JOBV .EQ. 'V' then N rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV .EQ. 'A' then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V', LDV .GE. N.",
       "         If JOBV = 'A', LDV .GE. MV."],
     "EPS"=>
      ["[in]",
       "         EPS is DOUBLE PRECISION",
       "         EPS = DLAMCH('Epsilon')"],
     "SFMIN"=>
      ["[in]",
       "         SFMIN is DOUBLE PRECISION",
       "         SFMIN = DLAMCH('Safe Minimum')"],
     "TOL"=>
      ["[in]",
       "         TOL is DOUBLE PRECISION",
       "         TOL is the threshold for Jacobi rotations. For a pair",
       "         A(:,p), A(:,q) of pivot columns, the Jacobi rotation is",
       "         applied only if DABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL."],
     "NSWEEP"=>
      ["[in]",
       "         NSWEEP is INTEGER",
       "         NSWEEP is the number of sweeps of Jacobi rotations to be",
       "         performed."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         LWORK is the dimension of WORK. LWORK .GE. M."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value"]}},
 "zhetrd"=>
  {"summary"=>
    ["ZHETRD reduces a complex Hermitian matrix A to real symmetric",
     "tridiagonal form T by a unitary similarity transformation:",
     "Q**H * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the unitary",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the unitary matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= 1.",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgetrs"=>
  {"summary"=>
    ["SGETRS solves a system of linear equations",
     "   A * X = B  or  A**T * X = B",
     "with a general N-by-N matrix A using the LU factorization computed",
     "by SGETRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T* X = B  (Transpose)",
       "         = 'C':  A**T* X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by SGETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from SGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlaqp2"=>
  {"summary"=>
    ["ZLAQP2 computes a QR factorization with column pivoting of",
     "the block A(OFFSET+1:M,1:N).",
     "The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0."],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         The number of rows of the matrix A that must be pivoted",
       "         but no factorized. OFFSET >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the upper triangle of block A(OFFSET+1:M,1:N) is",
       "         the triangular factor obtained; the elements in block",
       "         A(OFFSET+1:M,1:N) below the diagonal, together with the",
       "         array TAU, represent the orthogonal matrix Q as a product of",
       "         elementary reflectors. Block A(1:OFFSET,1:N) has been",
       "         accordingly pivoted, but no factorized."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(i) .ne. 0, the i-th column of A is permuted",
       "         to the front of A*P (a leading column); if JPVT(i) = 0,",
       "         the i-th column of A is a free column.",
       "         On exit, if JPVT(i) = k, then the i-th column of A*P",
       "         was the k-th column of A."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors."],
     "VN1"=>
      ["[in,out]",
       "         VN1 is DOUBLE PRECISION array, dimension (N)",
       "         The vector with the partial column norms."],
     "VN2"=>
      ["[in,out]",
       "         VN2 is DOUBLE PRECISION array, dimension (N)",
       "         The vector with the exact column norms."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"]}},
 "dbdsvdx"=>
  {"summary"=>
    [" DBDSVDX computes the singular value decomposition (SVD) of a real",
     " N-by-N (upper or lower) bidiagonal matrix B, B = U * S * VT,",
     " where S is a diagonal matrix with non-negative diagonal elements",
     " (the singular values of B), and U and VT are orthogonal matrices",
     " of left and right singular vectors, respectively.",
     " Given an upper bidiagonal B with diagonal D = [ d_1 d_2 ... d_N ]",
     " and superdiagonal E = [ e_1 e_2 ... e_N-1 ], DBDSVDX computes the",
     " singular value decompositon of B through the eigenvalues and",
     " eigenvectors of the N*2-by-N*2 tridiagonal matrix",
     "       |  0  d_1                |",
     "       | d_1  0  e_1            |",
     " TGK = |     e_1  0  d_2        |",
     "       |         d_2  .   .     |",
     "       |              .   .   . |",
     " If (s,u,v) is a singular triplet of B with ||u|| = ||v|| = 1, then",
     " (+/-s,q), ||q|| = 1, are eigenpairs of TGK, with q = P * ( u' +/-v' ) /",
     " sqrt(2) = ( v_1 u_1 v_2 u_2 ... v_n u_n ) / sqrt(2), and",
     " P = [ e_{n+1} e_{1} e_{n+2} e_{2} ... ].",
     " Given a TGK matrix, one can either a) compute -s,-v and change signs",
     " so that the singular values (and corresponding vectors) are already in",
     " descending order (as in DGESVD/DGESDD) or b) compute s,v and reorder",
     " the values (and corresponding vectors). DBDSVDX implements a) by",
     " calling DSTEVX (bisection plus inverse iteration, to be replaced",
     " with a version of the Multiple Relative Robust Representation",
     " algorithm. (See P. Willems and B. Lang, A framework for the MR^3",
     " algorithm: theory and implementation, SIAM J. Sci. Comput.,",
     " 35:740-766, 2013.)"],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  B is upper bidiagonal;",
       "         = 'L':  B is lower bidiagonal."],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute singular values only;",
       "         = 'V':  Compute singular values and singular vectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all singular values will be found.",
       "         = 'V': all singular values in the half-open interval [VL,VU)",
       "                will be found.",
       "         = 'I': the IL-th through IU-th singular values will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the bidiagonal matrix.  N >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the bidiagonal matrix B."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (max(1,N-1))",
       "         The (n-1) superdiagonal elements of the bidiagonal matrix",
       "         B in elements 1 to N-1."],
     "VL"=>
      ["[in]",
       "        VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "        VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "NS"=>
      ["[out]",
       "         NS is INTEGER",
       "         The total number of singular values found.  0 <= NS <= N.",
       "         If RANGE = 'A', NS = N, and if RANGE = 'I', NS = IU-IL+1."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         The first NS elements contain the selected singular values in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (2*N,K) )",
       "         If JOBZ = 'V', then if INFO = 0 the first NS columns of Z",
       "         contain the singular vectors of the matrix B corresponding to",
       "         the selected singular values, with U in rows 1 to N and V",
       "         in rows N+1 to N*2, i.e.",
       "         Z = [ U ]",
       "             [ V ]",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: The user must ensure that at least K = NS+1 columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of",
       "         NS is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(2,N*2)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (14*N)"],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (12*N)",
       "         If JOBZ = 'V', then if INFO = 0, the first NS elements of",
       "         IWORK are zero. If INFO > 0, then IWORK contains the indices",
       "         of the eigenvectors that failed to converge in DSTEVX."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge",
       "                  in DSTEVX. The indices of the eigenvectors",
       "                  (as returned by DSTEVX) are stored in the",
       "                  array IWORK.",
       "               if INFO = N*2 + 1, an internal error occurred."]}},
 "cgemqrt"=>
  {"summary"=>
    ["CGEMQRT overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q C            C Q",
     "TRANS = 'C':    Q**H C            C Q**H",
     "where Q is a complex orthogonal matrix defined as the product of K",
     "elementary reflectors:",
     "      Q = H(1) H(2) . . . H(K) = I - V T V**H",
     "generated using the compact WY representation as returned by CGEQRT.",
     "Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size used for the storage of T.  K >= NB >= 1.",
       "         This must be the same value of NB used to generate T",
       "         in CGEQRT."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension (LDV,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGEQRT in the first K columns of its array argument A."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by CGEQRT, stored as a NB-by-N matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q C, Q**H C, C Q**H or C Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array. The dimension of WORK is",
       "          N*NB if SIDE = 'L', or  M*NB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sstev"=>
  {"summary"=>
    ["SSTEV computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric tridiagonal matrix A."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A, stored in elements 1 to N-1 of E.",
       "         On exit, the contents of E are destroyed."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with D(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (max(1,2*N-2))",
       "         If JOBZ = 'N', WORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of E did not converge to zero."]}},
 "zlange"=>
  {"summary"=>
    ["ZLANGE  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex matrix A.",
     "   ZLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANGE as described",
       "         above."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0.  When M = 0,",
       "         ZLANGE is set to zero."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0.  When N = 0,",
       "         ZLANGE is set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= M when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "sorbdb3"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M. M-P <= min(P,Q,M-Q)."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is REAL array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is REAL array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is REAL array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is REAL array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is REAL array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is REAL array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "sbdsqr"=>
  {"summary"=>
    ["SBDSQR computes the singular values and, optionally, the right and/or",
     "left singular vectors from the singular value decomposition (SVD) of",
     "a real N-by-N (upper or lower) bidiagonal matrix B using the implicit",
     "zero-shift QR algorithm.  The SVD of B has the form",
     "   B = Q * S * P**T",
     "where S is the diagonal matrix of singular values, Q is an orthogonal",
     "matrix of left singular vectors, and P is an orthogonal matrix of",
     "right singular vectors.  If left singular vectors are requested, this",
     "subroutine actually returns U*Q instead of Q, and, if right singular",
     "vectors are requested, this subroutine returns P**T*VT instead of",
     "P**T, for given real input matrices U and VT.  When U and VT are the",
     "orthogonal matrices that reduce a general matrix A to bidiagonal",
     "form:  A = U*B*VT, as computed by SGEBRD, then",
     "   A = (U*Q) * S * (P**T*VT)",
     "is the SVD of A.  Optionally, the subroutine may also compute Q**T*C",
     "for a given real input matrix C.",
     "See \"Computing  Small Singular Values of Bidiagonal Matrices With",
     "Guaranteed High Relative Accuracy,\" by J. Demmel and W. Kahan,",
     "LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11,",
     "no. 5, pp. 873-912, Sept 1990) and",
     "\"Accurate singular values and differential qd algorithms,\" by",
     "B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics",
     "Department, University of California at Berkeley, July 1992",
     "for a detailed description of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  B is upper bidiagonal;",
       "         = 'L':  B is lower bidiagonal."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix B.  N >= 0."],
     "NCVT"=>
      ["[in]",
       "         NCVT is INTEGER",
       "         The number of columns of the matrix VT. NCVT >= 0."],
     "NRU"=>
      ["[in]",
       "         NRU is INTEGER",
       "         The number of rows of the matrix U. NRU >= 0."],
     "NCC"=>
      ["[in]",
       "         NCC is INTEGER",
       "         The number of columns of the matrix C. NCC >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the bidiagonal matrix B.",
       "         On exit, if INFO=0, the singular values of B in decreasing",
       "         order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the N-1 offdiagonal elements of the bidiagonal",
       "         matrix B.",
       "         On exit, if INFO = 0, E is destroyed; if INFO > 0, D and E",
       "         will contain the diagonal and superdiagonal elements of a",
       "         bidiagonal matrix orthogonally equivalent to the one given",
       "         as input."],
     "VT"=>
      ["[in,out]",
       "         VT is REAL array, dimension (LDVT, NCVT)",
       "         On entry, an N-by-NCVT matrix VT.",
       "         On exit, VT is overwritten by P**T * VT.",
       "         Not referenced if NCVT = 0."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.",
       "         LDVT >= max(1,N) if NCVT > 0; LDVT >= 1 if NCVT = 0."],
     "U"=>
      ["[in,out]",
       "         U is REAL array, dimension (LDU, N)",
       "         On entry, an NRU-by-N matrix U.",
       "         On exit, U is overwritten by U * Q.",
       "         Not referenced if NRU = 0."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= max(1,NRU)."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC, NCC)",
       "         On entry, an N-by-NCC matrix C.",
       "         On exit, C is overwritten by Q**T * C.",
       "         Not referenced if NCC = 0."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.",
       "         LDC >= max(1,N) if NCC > 0; LDC >=1 if NCC = 0."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  If INFO = -i, the i-th argument had an illegal value",
       "         > 0:",
       "            if NCVT = NRU = NCC = 0,",
       "               = 1, a split was marked by a positive value in E",
       "               = 2, current block of Z not diagonalized after 30*N",
       "                    iterations (in inner while loop)",
       "               = 3, termination criterion of outer while loop not met",
       "                    (program created more than N unreduced blocks)",
       "            else NCVT = NRU = NCC = 0,",
       "                  the algorithm did not converge; D and E contain the",
       "                  elements of a bidiagonal matrix which is orthogonally",
       "                  similar to the input matrix B;  if INFO = i, i",
       "                  elements of E have not converged to zero."]}},
 "csytf2_rook"=>
  {"summary"=>
    ["CSYTF2_ROOK computes the factorization of a complex symmetric matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**T is the transpose of U, and D is symmetric and",
     "block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "sstegr"=>
  {"summary"=>
    ["SSTEGR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix T. Any such unreduced matrix has",
     "a well defined set of pairwise different real eigenvalues, the corresponding",
     "real eigenvectors are pairwise orthogonal.",
     "The spectrum may be computed either completely or partially by specifying",
     "either an interval (VL,VU] or a range of indices IL:IU for the desired",
     "eigenvalues.",
     "SSTEGR is a compatibility wrapper around the improved SSTEMR routine.",
     "See SSTEMR for further details.",
     "One important change is that the ABSTOL parameter no longer provides any",
     "benefit and hence is no longer used.",
     "Note : SSTEGR and SSTEMR work only on machines which follow",
     "IEEE-754 floating-point standard in their handling of infinities and",
     "NaNs.  Normal execution may create these exceptiona values and hence",
     "may abort due to a floating point exception in environments which",
     "do not conform to the IEEE-754 standard."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal matrix",
       "         T. On exit, D is overwritten."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the tridiagonal",
       "         matrix T in elements 1 to N-1 of E. E(N) need not be set on",
       "         input, but is used internally as workspace.",
       "         On exit, E is overwritten."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         Unused.  Was the absolute error tolerance for the",
       "         eigenvalues/eigenvectors in previous versions."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', and if INFO = 0, then the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix T",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used.",
       "         Supplying N columns is always safe."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', then LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER ARRAY, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th computed eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is relevant in the case when the matrix",
       "         is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal",
       "         (and minimal) LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,18*N)",
       "         if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (LIWORK)",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N)",
       "         if the eigenvectors are desired, and LIWORK >= max(1,8*N)",
       "         if only the eigenvalues are to be computed.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = 1X, internal error in SLARRE,",
       "               if INFO = 2X, internal error in SLARRV.",
       "               Here, the digit X = ABS( IINFO ) < 10, where IINFO is",
       "               the nonzero error code returned by SLARRE or",
       "               SLARRV, respectively."]}},
 "dgbsvx"=>
  {"summary"=>
    ["DGBSVX uses the LU factorization to compute the solution to a real",
     "system of linear equations A * X = B, A**T * X = B, or A**H * X = B,",
     "where A is a band matrix of order N with KL subdiagonals and KU",
     "superdiagonals, and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "dsygs2"=>
  {"summary"=>
    ["DSYGS2 reduces a real symmetric-definite generalized eigenproblem",
     "to standard form.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T *A*L.",
     "B must have been previously factorized as U**T *U or L*L**T by DPOTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T);",
       "         = 2 or 3: compute U*A*U**T or L**T *A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored, and how B has been factorized.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         as returned by DPOTRF."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "xerbla_array"=>
  {"summary"=>
    ["XERBLA_ARRAY assists other languages in calling XERBLA, the LAPACK",
     "and BLAS error handler.  Rather than taking a Fortran string argument",
     "as the function's name, XERBLA_ARRAY takes an array of single",
     "characters along with the array's length.  XERBLA_ARRAY then copies",
     "up to 32 characters of that array into a Fortran string and passes",
     "that to XERBLA.  If called with a non-positive SRNAME_LEN,",
     "XERBLA_ARRAY will call XERBLA with a string of all blank characters.",
     "Say some macro or other device makes XERBLA_ARRAY available to C99",
     "by a name lapack_xerbla and with a common Fortran calling convention.",
     "Then a C99 program could invoke XERBLA via:",
     "   {",
     "     int flen = strlen(__func__);",
     "     lapack_xerbla(__func__, &flen, &info);",
     "   }",
     "Providing XERBLA_ARRAY is not necessary for intercepting LAPACK",
     "errors.  XERBLA_ARRAY calls XERBLA."],
   "param"=>
    {"SRNAME_ARRAY"=>
      ["[in]",
       "         SRNAME_ARRAY is CHARACTER(1) array, dimension (SRNAME_LEN)",
       "         The name of the routine which called XERBLA_ARRAY."],
     "SRNAME_LEN"=>
      ["[in]",
       "         SRNAME_LEN is INTEGER",
       "         The length of the name in SRNAME_ARRAY."],
     "INFO"=>
      ["[in]",
       "         INFO is INTEGER",
       "         The position of the invalid parameter in the parameter list",
       "         of the calling routine."]}},
 "sgehd2"=>
  {"summary"=>
    ["SGEHD2 reduces a real general matrix A to upper Hessenberg form H by",
     "an orthogonal similarity transformation:  Q**T * A * Q = H ."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that A is already upper triangular in rows",
       "         and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "         set by a previous call to SGEBAL; otherwise they should be",
       "         set to 1 and N respectively. See Further Details.",
       "         1 <= ILO <= IHI <= max(1,N)."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the n by n general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         elements below the first subdiagonal, with the array TAU,",
       "         represent the orthogonal matrix Q as a product of elementary",
       "         reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zungqr"=>
  {"summary"=>
    ["ZUNGQR generates an M-by-N complex matrix Q with orthonormal columns,",
     "which is defined as the first N columns of a product of K elementary",
     "reflectors of order M",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by ZGEQRF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the i-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by ZGEQRF in the first k columns of its array",
       "         argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGEQRF."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "slaswlq"=>
  {"summary"=>
    ["         SLASWLQ computes a blocked Short-Wide LQ factorization of a",
     "         M-by-N matrix A, where N >= M:",
     "         A = L * Q"],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= M >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         M >= MB >= 1"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         NB > M."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and bleow the diagonal",
       "         of the array contain the N-by-N lower triangular matrix L;",
       "         the elements above the diagonal represent Q by the rows",
       "         of blocked V (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array,",
       "         dimension (LDT, N * Number_of_row_blocks)",
       "         where Number_of_row_blocks = CEIL((N-M)/(NB-M))",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.",
       "         See Further Details below."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>
      ["[out]", "        (workspace) REAL array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         The dimension of the array WORK.  LWORK >= MB * M.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlacon"=>
  {"summary"=>
    ["ZLACON estimates the 1-norm of a square, complex matrix A.",
     "Reverse communication is used for evaluating matrix-vector products."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The order of the matrix.  N >= 1."],
     "V"=>
      ["[out]",
       "         V is COMPLEX*16 array, dimension (N)",
       "        On the final return, V = A*W,  where  EST = norm(V)/norm(W)",
       "        (W is not returned)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (N)",
       "        On an intermediate return, X should be overwritten by",
       "              A * X,   if KASE=1,",
       "              A**H * X,  if KASE=2,",
       "        where A**H is the conjugate transpose of A, and ZLACON must be",
       "        re-called with all the other parameters unchanged."],
     "EST"=>
      ["[in,out]",
       "         EST is DOUBLE PRECISION",
       "        On entry with KASE = 1 or 2 and JUMP = 3, EST should be",
       "        unchanged from the previous call to ZLACON.",
       "        On exit, EST is an estimate (a lower bound) for norm(A)."],
     "KASE"=>
      ["[in,out]",
       "         KASE is INTEGER",
       "        On the initial call to ZLACON, KASE should be 0.",
       "        On an intermediate return, KASE will be 1 or 2, indicating",
       "        whether X should be overwritten by A * X  or A**H * X.",
       "        On the final return from ZLACON, KASE will again be 0."]}},
 "zung2r"=>
  {"summary"=>
    ["ZUNG2R generates an m by n complex matrix Q with orthonormal columns,",
     "which is defined as the first n columns of a product of k elementary",
     "reflectors of order m",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by ZGEQRF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the i-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by ZGEQRF in the first k columns of its array",
       "         argument A.",
       "         On exit, the m by n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGEQRF."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "zunbdb4"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M and",
       "          M-Q <= min(P,M-P,Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX*16 array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX*16 array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is COMPLEX*16 array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is COMPLEX*16 array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is COMPLEX*16 array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "PHANTOM"=>
      ["[out]",
       "         PHANTOM is COMPLEX*16 array, dimension (M)",
       "          The routine computes an M-by-1 column vector Y that is",
       "          orthogonal to the columns of [ X11; X21 ]. PHANTOM(1:P) and",
       "          PHANTOM(P+1:M) contain Householder vectors for Y(1:P) and",
       "          Y(P+1:M), respectively."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dsbevx_2stage"=>
  {"summary"=>
    ["DSBEVX_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric band matrix A using the 2stage technique for",
     "the reduction to tridiagonal. Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "Q"=>
      ["[out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the N-by-N orthogonal matrix used in the",
       "                        reduction to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'V', then",
       "         LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AB to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, 7*N, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS + 2*N",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "zpotrs"=>
  {"summary"=>
    ["ZPOTRS solves a system of linear equations A*X = B with a Hermitian",
     "positive definite matrix A using the Cholesky factorization",
     "A = U**H * U or A = L * L**H computed by ZPOTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H * U or A = L * L**H, as computed by ZPOTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zsyconvf_rook"=>
  {"summary"=>
    ["If parameter WAY = 'C':",
     "ZSYCONVF_ROOK converts the factorization output format used in",
     "ZSYTRF_ROOK provided on entry in parameter A into the factorization",
     "output format used in ZSYTRF_RK (or ZSYTRF_BK) that is stored",
     "on exit in parameters A and E. IPIV format for ZSYTRF_ROOK and",
     "ZSYTRF_RK (or ZSYTRF_BK) is the same and is not converted.",
     "If parameter WAY = 'R':",
     "ZSYCONVF_ROOK performs the conversion in reverse direction, i.e.",
     "converts the factorization output format used in ZSYTRF_RK",
     "(or ZSYTRF_BK) provided on entry in parametes A and E into",
     "the factorization output format used in ZSYTRF_ROOK that is stored",
     "on exit in parameter A. IPIV format for ZSYTRF_ROOK and",
     "ZSYTRF_RK (or ZSYTRF_BK) is the same and is not converted.",
     "ZSYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between",
     "formats used in ZHETRF_ROOK and ZHETRF_RK (or ZHETRF_BK)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix A.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         1) If WAY ='C':",
       "         On entry, contains factorization details in format used in",
       "         ZSYTRF_ROOK:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         ZSYTRF_RK or ZSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         2) If WAY = 'R':",
       "         On entry, contains factorization details in format used in",
       "         ZSYTRF_RK or ZSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         ZSYTRF_ROOK:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in,out]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, just a workspace.",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         2) If WAY = 'R':",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not referenced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         On exit, is not changed"],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On entry, details of the interchanges and the block",
       "         structure of D as determined:",
       "         1) by ZSYTRF_ROOK, if WAY ='C';",
       "         2) by ZSYTRF_RK (or ZSYTRF_BK), if WAY ='R'.",
       "         The IPIV format is the same for all these routines.",
       "         On exit, is not changed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sorbdb5"=>
  {"summary"=>[],
   "param"=>
    {"M1"=>
      ["[in]",
       "         M1 is INTEGER",
       "          The dimension of X1 and the number of rows in Q1. 0 <= M1."],
     "M2"=>
      ["[in]",
       "         M2 is INTEGER",
       "          The dimension of X2 and the number of rows in Q2. 0 <= M2."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The number of columns in Q1 and Q2. 0 <= N."],
     "X1"=>
      ["[in,out]",
       "         X1 is REAL array, dimension (M1)",
       "          On entry, the top part of the vector to be orthogonalized.",
       "          On exit, the top part of the projected vector."],
     "INCX1"=>
      ["[in]",
       "         INCX1 is INTEGER",
       "          Increment for entries of X1."],
     "X2"=>
      ["[in,out]",
       "         X2 is REAL array, dimension (M2)",
       "          On entry, the bottom part of the vector to be",
       "          orthogonalized. On exit, the bottom part of the projected",
       "          vector."],
     "INCX2"=>
      ["[in]",
       "         INCX2 is INTEGER",
       "          Increment for entries of X2."],
     "Q1"=>
      ["[in]",
       "         Q1 is REAL array, dimension (LDQ1, N)",
       "          The top part of the orthonormal basis matrix."],
     "LDQ1"=>
      ["[in]",
       "         LDQ1 is INTEGER",
       "          The leading dimension of Q1. LDQ1 >= M1."],
     "Q2"=>
      ["[in]",
       "         Q2 is REAL array, dimension (LDQ2, N)",
       "          The bottom part of the orthonormal basis matrix."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "          The leading dimension of Q2. LDQ2 >= M2."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "clapmr"=>
  {"summary"=>
    ["CLAPMR rearranges the rows of the M by N matrix X as specified",
     "by the permutation K(1),K(2),...,K(M) of the integers 1,...,M.",
     "If FORWRD = .TRUE.,  forward permutation:",
     "     X(K(I),*) is moved X(I,*) for I = 1,2,...,M.",
     "If FORWRD = .FALSE., backward permutation:",
     "     X(I,*) is moved to X(K(I),*) for I = 1,2,...,M."],
   "param"=>
    {"FORWRD"=>
      ["[in]",
       "         FORWRD is LOGICAL",
       "         = .TRUE., forward permutation",
       "         = .FALSE., backward permutation"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix X. N >= 0."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,N)",
       "         On entry, the M by N matrix X.",
       "         On exit, X contains the permuted matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X, LDX >= MAX(1,M)."],
     "K"=>
      ["[in,out]",
       "         K is INTEGER array, dimension (M)",
       "         On entry, K contains the permutation vector. K is used as",
       "         internal workspace, but reset to its original value on",
       "         output."]}},
 "dgtts2"=>
  {"summary"=>
    ["DGTTS2 solves one of the systems of equations",
     "   A*X = B  or  A**T*X = B,",
     "with a tridiagonal matrix A using the LU factorization computed",
     "by DGTTRF."],
   "param"=>
    {"ITRANS"=>
      ["[in]",
       "         ITRANS is INTEGER",
       "         Specifies the form of the system of equations.",
       "         = 0:  A * X = B  (No transpose)",
       "         = 1:  A**T* X = B  (Transpose)",
       "         = 2:  A**T* X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) elements of the first super-diagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is DOUBLE PRECISION array, dimension (N-2)",
       "         The (n-2) elements of the second super-diagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the matrix of right hand side vectors B.",
       "         On exit, B is overwritten by the solution vectors X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."]}},
 "ztgexc"=>
  {"summary"=>
    ["ZTGEXC reorders the generalized Schur decomposition of a complex",
     "matrix pair (A,B), using an unitary equivalence transformation",
     "(A, B) := Q * (A, B) * Z**H, so that the diagonal block of (A, B) with",
     "row index IFST is moved to row ILST.",
     "(A, B) must be in generalized Schur canonical form, that is, A and",
     "B are both upper triangular.",
     "Optionally, the matrices Q and Z of generalized Schur vectors are",
     "updated.",
     "       Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H",
     "       Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H"],
   "param"=>
    {"WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the upper triangular matrix A in the pair (A, B).",
       "         On exit, the updated matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the upper triangular matrix B in the pair (A, B).",
       "         On exit, the updated matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDZ,N)",
       "         On entry, if WANTQ = .TRUE., the unitary matrix Q.",
       "         On exit, the updated matrix Q.",
       "         If WANTQ = .FALSE., Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= 1;",
       "         If WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ,N)",
       "         On entry, if WANTZ = .TRUE., the unitary matrix Z.",
       "         On exit, the updated matrix Z.",
       "         If WANTZ = .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1;",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "IFST"=>["[in]", "         IFST is INTEGER"],
     "ILST"=>
      ["[in,out]",
       "         ILST is INTEGER",
       "         Specify the reordering of the diagonal blocks of (A, B).",
       "         The block with row index IFST is moved to row ILST, by a",
       "         sequence of swapping between adjacent blocks."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          =0:  Successful exit.",
       "          <0:  if INFO = -i, the i-th argument had an illegal value.",
       "          =1:  The transformed matrix pair (A, B) would be too far",
       "               from generalized Schur form; the problem is ill-",
       "               conditioned. (A, B) may have been partially reordered,",
       "               and ILST points to the first row of the current",
       "               position of the block being moved."]}},
 "dlanv2"=>
  {"summary"=>
    ["DLANV2 computes the Schur factorization of a real 2-by-2 nonsymmetric",
     "matrix in standard form:",
     "     [ A  B ] = [ CS -SN ] [ AA  BB ] [ CS  SN ]",
     "     [ C  D ]   [ SN  CS ] [ CC  DD ] [-SN  CS ]",
     "where either",
     "1) CC = 0 so that AA and DD are real eigenvalues of the matrix, or",
     "2) AA = DD and BB*CC < 0, so that AA + or - sqrt(BB*CC) are complex",
     "conjugate eigenvalues."],
   "param"=>
    {"A"=>["[in,out]", "         A is DOUBLE PRECISION"],
     "B"=>["[in,out]", "         B is DOUBLE PRECISION"],
     "C"=>["[in,out]", "         C is DOUBLE PRECISION"],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION",
       "         On entry, the elements of the input matrix.",
       "         On exit, they are overwritten by the elements of the",
       "         standardised Schur form."],
     "RT1R"=>["[out]", "         RT1R is DOUBLE PRECISION"],
     "RT1I"=>["[out]", "         RT1I is DOUBLE PRECISION"],
     "RT2R"=>["[out]", "         RT2R is DOUBLE PRECISION"],
     "RT2I"=>
      ["[out]",
       "         RT2I is DOUBLE PRECISION",
       "         The real and imaginary parts of the eigenvalues. If the",
       "         eigenvalues are a complex conjugate pair, RT1I > 0."],
     "CS"=>["[out]", "         CS is DOUBLE PRECISION"],
     "SN"=>
      ["[out]",
       "         SN is DOUBLE PRECISION",
       "         Parameters of the rotation matrix."]}},
 "ssbevd"=>
  {"summary"=>
    ["SSBEVD computes all the eigenvalues and, optionally, eigenvectors of",
     "a real symmetric band matrix A. If eigenvectors are desired, it uses",
     "a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array,",
       "                                        dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         IF N <= 1,                LWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 2, LWORK must be at least 2*N.",
       "         If JOBZ  = 'V' and N > 2, LWORK must be at least",
       "                        ( 1 + 5*N + 2*N**2 ).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 2, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dlagtf"=>
  {"summary"=>
    ["DLAGTF factorizes the matrix (T - lambda*I), where T is an n by n",
     "tridiagonal matrix and lambda is a scalar, as",
     "   T - lambda*I = PLU,",
     "where P is a permutation matrix, L is a unit lower tridiagonal matrix",
     "with at most one non-zero sub-diagonal elements per column and U is",
     "an upper triangular matrix with at most two non-zero super-diagonal",
     "elements per column.",
     "The factorization is obtained by Gaussian elimination with partial",
     "pivoting and implicit row scaling.",
     "The parameter LAMBDA is included in the routine so that DLAGTF may",
     "be used, in conjunction with DLAGTS, to obtain eigenvectors of T by",
     "inverse iteration."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix T."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (N)",
       "         On entry, A must contain the diagonal elements of T.",
       "         On exit, A is overwritten by the n diagonal elements of the",
       "         upper triangular matrix U of the factorization of T."],
     "LAMBDA"=>
      ["[in]",
       "         LAMBDA is DOUBLE PRECISION",
       "         On entry, the scalar lambda."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, B must contain the (n-1) super-diagonal elements of",
       "         T.",
       "         On exit, B is overwritten by the (n-1) super-diagonal",
       "         elements of the matrix U of the factorization of T."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, C must contain the (n-1) sub-diagonal elements of",
       "         T.",
       "         On exit, C is overwritten by the (n-1) sub-diagonal elements",
       "         of the matrix L of the factorization of T."],
     "TOL"=>
      ["[in]",
       "         TOL is DOUBLE PRECISION",
       "         On entry, a relative tolerance used to indicate whether or",
       "         not the matrix (T - lambda*I) is nearly singular. TOL should",
       "         normally be chose as approximately the largest relative error",
       "         in the elements of T. For example, if the elements of T are",
       "         correct to about 4 significant figures, then TOL should be",
       "         set to about 5*10**(-4). If TOL is supplied as less than eps,",
       "         where eps is the relative machine precision, then the value",
       "         eps is used in place of TOL."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N-2)",
       "         On exit, D is overwritten by the (n-2) second super-diagonal",
       "         elements of the matrix U of the factorization of T."],
     "IN"=>
      ["[out]",
       "         IN is INTEGER array, dimension (N)",
       "         On exit, IN contains details of the permutation matrix P. If",
       "         an interchange occurred at the kth step of the elimination,",
       "         then IN(k) = 1, otherwise IN(k) = 0. The element IN(n)",
       "         returns the smallest positive integer j such that",
       "            abs( u(j,j) ).le. norm( (T - lambda*I)(j) )*TOL,",
       "         where norm( A(j) ) denotes the sum of the absolute values of",
       "         the jth row of the matrix A. If no such j exists then IN(n)",
       "         is returned as zero. If IN(n) is returned as positive, then a",
       "         diagonal element of U is small, indicating that",
       "         (T - lambda*I) is singular or nearly singular,"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0   : successful exit",
       "         .lt. 0: if INFO = -k, the kth argument had an illegal value"]}},
 "sla_wwaddw"=>
  {"summary"=>
    ["   SLA_WWADDW adds a vector W into a doubled-single vector (X, Y).",
     "   This works for all extant IBM's hex and binary floating point",
     "   arithmetics, but not for decimal."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "           The length of vectors X, Y, and W."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (N)",
       "           The first part of the doubled-single accumulation vector."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension (N)",
       "           The second part of the doubled-single accumulation vector."],
     "W"=>
      ["[in]",
       "         W is REAL array, dimension (N)",
       "           The vector to be added."]}},
 "sgemqrt"=>
  {"summary"=>
    ["SGEMQRT overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q C            C Q",
     "TRANS = 'T':   Q**T C            C Q**T",
     "where Q is a real orthogonal matrix defined as the product of K",
     "elementary reflectors:",
     "      Q = H(1) H(2) . . . H(K) = I - V T V**T",
     "generated using the compact WY representation as returned by SGEQRT.",
     "Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size used for the storage of T.  K >= NB >= 1.",
       "         This must be the same value of NB used to generate T",
       "         in CGEQRT."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension (LDV,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGEQRT in the first K columns of its array argument A."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by CGEQRT, stored as a NB-by-N matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q C, Q**T C, C Q**T or C Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array. The dimension of WORK is",
       "          N*NB if SIDE = 'L', or  M*NB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgttrs"=>
  {"summary"=>
    ["DGTTRS solves one of the systems of equations",
     "   A*X = B  or  A**T*X = B,",
     "with a tridiagonal matrix A using the LU factorization computed",
     "by DGTTRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations.",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T* X = B  (Transpose)",
       "         = 'C':  A**T* X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) elements of the first super-diagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is DOUBLE PRECISION array, dimension (N-2)",
       "         The (n-2) elements of the second super-diagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the matrix of right hand side vectors B.",
       "         On exit, B is overwritten by the solution vectors X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clagtm"=>
  {"summary"=>
    ["CLAGTM performs a matrix-vector product of the form",
     "   B := alpha * A * X + beta * B",
     "where A is a tridiagonal matrix of order N, B and X are N by NRHS",
     "matrices, and alpha and beta are real scalars, each of which may be",
     "0., 1., or -1."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  No transpose, B := alpha * A * X + beta * B",
       "         = 'T':  Transpose,    B := alpha * A**T * X + beta * B",
       "         = 'C':  Conjugate transpose, B := alpha * A**H * X + beta * B"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices X and B."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "         The scalar alpha.  ALPHA must be 0., 1., or -1.; otherwise,",
       "         it is assumed to be 0."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX array, dimension (N-1)",
       "         The (n-1) sub-diagonal elements of T."],
     "D"=>
      ["[in]",
       "         D is COMPLEX array, dimension (N)",
       "         The diagonal elements of T."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX array, dimension (N-1)",
       "         The (n-1) super-diagonal elements of T."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         The N by NRHS matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(N,1)."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL",
       "         The scalar beta.  BETA must be 0., 1., or -1.; otherwise,",
       "         it is assumed to be 1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N by NRHS matrix B.",
       "         On exit, B is overwritten by the matrix expression",
       "         B := alpha * A * X + beta * B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(N,1)."]}},
 "dpftrs"=>
  {"summary"=>
    ["DPFTRS solves a system of linear equations A*X = B with a symmetric",
     "positive definite matrix A using the Cholesky factorization",
     "A = U**T*U or A = L*L**T computed by DPFTRF."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'T':  The Transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of RFP A is stored;",
       "         = 'L':  Lower triangle of RFP A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension ( N*(N+1)/2 ).",
       "         The triangular factor U or L from the Cholesky factorization",
       "         of RFP A = U**T*U or RFP A = L*L**T, as computed by DPFTRF.",
       "         See note below for more details about RFP A."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaed0"=>
  {"summary"=>
    ["DLAED0 computes all eigenvalues and corresponding eigenvectors of a",
     "symmetric tridiagonal matrix using the divide and conquer method."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "         = 0:  Compute eigenvalues only.",
       "         = 1:  Compute eigenvectors of original dense symmetric matrix",
       "               also.  On entry, Q contains the orthogonal matrix used",
       "               to reduce the original matrix to tridiagonal form.",
       "         = 2:  Compute eigenvalues and eigenvectors of tridiagonal",
       "               matrix."],
     "QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the orthogonal matrix used to reduce",
       "        the full matrix to tridiagonal form.  QSIZ >= N if ICOMPQ = 1."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        On entry, the main diagonal of the tridiagonal matrix.",
       "        On exit, its eigenvalues."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "        The off-diagonal elements of the tridiagonal matrix.",
       "        On exit, E has been destroyed."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ, N)",
       "        On entry, Q must contain an N-by-N orthogonal matrix.",
       "        If ICOMPQ = 0    Q is not referenced.",
       "        If ICOMPQ = 1    On entry, Q is a subset of the columns of the",
       "                         orthogonal matrix used to reduce the full",
       "                         matrix to tridiagonal form corresponding to",
       "                         the subset of the full matrix which is being",
       "                         decomposed at this time.",
       "        If ICOMPQ = 2    On entry, Q will be the identity matrix.",
       "                         On exit, Q contains the eigenvectors of the",
       "                         tridiagonal matrix."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  If eigenvectors are",
       "        desired, then  LDQ >= max(1,N).  In any case,  LDQ >= 1."],
     "QSTORE"=>
      ["[out]",
       "         QSTORE is DOUBLE PRECISION array, dimension (LDQS, N)",
       "        Referenced only when ICOMPQ = 1.  Used to store parts of",
       "        the eigenvector matrix when the updating matrix multiplies",
       "        take place."],
     "LDQS"=>
      ["[in]",
       "         LDQS is INTEGER",
       "        The leading dimension of the array QSTORE.  If ICOMPQ = 1,",
       "        then  LDQS >= max(1,N).  In any case,  LDQS >= 1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array,",
       "        If ICOMPQ = 0 or 1, the dimension of WORK must be at least",
       "                    1 + 3*N + 2*N*lg N + 3*N**2",
       "                    ( lg( N ) = smallest integer k",
       "                                such that 2^k >= N )",
       "        If ICOMPQ = 2, the dimension of WORK must be at least",
       "                    4*N + N**2."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array,",
       "        If ICOMPQ = 0 or 1, the dimension of IWORK must be at least",
       "                       6 + 6*N + 5*N*lg N.",
       "                       ( lg( N ) = smallest integer k",
       "                                   such that 2^k >= N )",
       "        If ICOMPQ = 2, the dimension of IWORK must be at least",
       "                       3 + 5*N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The algorithm failed to compute an eigenvalue while",
       "               working on the submatrix lying in rows and columns",
       "               INFO/(N+1) through mod(INFO,N+1)."]}},
 "cunmlq"=>
  {"summary"=>
    ["CUNMLQ overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k)**H . . . H(2)**H H(1)**H",
     "as returned by CGELQF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGELQF in the first k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGELQF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "spotrs"=>
  {"summary"=>
    ["SPOTRS solves a system of linear equations A*X = B with a symmetric",
     "positive definite matrix A using the Cholesky factorization",
     "A = U**T*U or A = L*L**T computed by SPOTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, as computed by SPOTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cspmv"=>
  {"summary"=>
    ["CSPMV  performs the matrix-vector operation",
     "   y := alpha*A*x + beta*y,",
     "where alpha and beta are scalars, x and y are n element vectors and",
     "A is an n by n symmetric matrix, supplied in packed form."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the matrix A is supplied in the packed",
       "          array AP as follows:",
       "             UPLO = 'U' or 'u'   The upper triangular part of A is",
       "                                 supplied in AP.",
       "             UPLO = 'L' or 'l'   The lower triangular part of A is",
       "                                 supplied in AP.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the order of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension at least",
       "          ( ( N*( N + 1 ) )/2 ).",
       "          Before entry, with UPLO = 'U' or 'u', the array AP must",
       "          contain the upper triangular part of the symmetric matrix",
       "          packed sequentially, column by column, so that AP( 1 )",
       "          contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 )",
       "          and a( 2, 2 ) respectively, and so on.",
       "          Before entry, with UPLO = 'L' or 'l', the array AP must",
       "          contain the lower triangular part of the symmetric matrix",
       "          packed sequentially, column by column, so that AP( 1 )",
       "          contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 )",
       "          and a( 3, 1 ) respectively, and so on.",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCX ) ).",
       "          Before entry, the incremented array X must contain the N-",
       "          element vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is COMPLEX",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCY ) ).",
       "          Before entry, the incremented array Y must contain the n",
       "          element vector y. On exit, Y is overwritten by the updated",
       "          vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit."]}},
 "sspgv"=>
  {"summary"=>
    ["SSPGV computes all the eigenvalues and, optionally, the eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be symmetric, stored in packed format,",
     "and B is also positive definite."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension",
       "                           (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T, in the same storage",
       "         format as B."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors.  The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  SPPTRF or SSPEV returned an error code:",
       "            <= N:  if INFO = i, SSPEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero.",
       "            > N:   if INFO = n + i, for 1 <= i <= n, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "zlaein"=>
  {"summary"=>
    ["ZLAEIN uses inverse iteration to find a right or left eigenvector",
     "corresponding to the eigenvalue W of a complex upper Hessenberg",
     "matrix H."],
   "param"=>
    {"RIGHTV"=>
      ["[in]",
       "         RIGHTV is LOGICAL",
       "         = .TRUE. : compute right eigenvector;",
       "         = .FALSE.: compute left eigenvector."],
     "NOINIT"=>
      ["[in]",
       "         NOINIT is LOGICAL",
       "         = .TRUE. : no initial vector supplied in V",
       "         = .FALSE.: initial vector supplied in V."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "H"=>
      ["[in]",
       "         H is COMPLEX*16 array, dimension (LDH,N)",
       "         The upper Hessenberg matrix H."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max(1,N)."],
     "W"=>
      ["[in]",
       "         W is COMPLEX*16",
       "         The eigenvalue of H whose corresponding right or left",
       "         eigenvector is to be computed."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX*16 array, dimension (N)",
       "         On entry, if NOINIT = .FALSE., V must contain a starting",
       "         vector for inverse iteration; otherwise V need not be set.",
       "         On exit, V contains the computed eigenvector, normalized so",
       "         that the component of largest magnitude has magnitude 1; here",
       "         the magnitude of a complex number (x,y) is taken to be",
       "         |x| + |y|."],
     "B"=>["[out]", "         B is COMPLEX*16 array, dimension (LDB,N)"],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "EPS3"=>
      ["[in]",
       "         EPS3 is DOUBLE PRECISION",
       "         A small machine-dependent value which is used to perturb",
       "         close eigenvalues, and to replace zero pivots."],
     "SMLNUM"=>
      ["[in]",
       "         SMLNUM is DOUBLE PRECISION",
       "         A machine-dependent value close to the underflow threshold."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         = 1:  inverse iteration did not converge; V is set to the",
       "               last iterate."]}},
 "ctrsyl"=>
  {"summary"=>
    ["CTRSYL solves the complex Sylvester matrix equation:",
     "   op(A)*X + X*op(B) = scale*C or",
     "   op(A)*X - X*op(B) = scale*C,",
     "where op(A) = A or A**H, and A and B are both upper triangular. A is",
     "M-by-M and B is N-by-N; the right hand side C and the solution X are",
     "M-by-N; and scale is an output scale factor, set <= 1 to avoid",
     "overflow in X."],
   "param"=>
    {"TRANA"=>
      ["[in]",
       "         TRANA is CHARACTER*1",
       "         Specifies the option op(A):",
       "         = 'N': op(A) = A    (No transpose)",
       "         = 'C': op(A) = A**H (Conjugate transpose)"],
     "TRANB"=>
      ["[in]",
       "         TRANB is CHARACTER*1",
       "         Specifies the option op(B):",
       "         = 'N': op(B) = B    (No transpose)",
       "         = 'C': op(B) = B**H (Conjugate transpose)"],
     "ISGN"=>
      ["[in]",
       "         ISGN is INTEGER",
       "         Specifies the sign in the equation:",
       "         = +1: solve op(A)*X + X*op(B) = scale*C",
       "         = -1: solve op(A)*X - X*op(B) = scale*C"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The order of the matrix A, and the number of rows in the",
       "         matrices X and C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix B, and the number of columns in the",
       "         matrices X and C. N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,M)",
       "         The upper triangular matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         The upper triangular matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N right hand side matrix C.",
       "         On exit, C is overwritten by the solution matrix X."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)"],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         The scale factor, scale, set <= 1 to avoid overflow in X."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         = 1: A and B have common or very close eigenvalues; perturbed",
       "              values were used to solve the equation (but the matrices",
       "              A and B are unchanged)."]}},
 "slasd2"=>
  {"summary"=>
    ["SLASD2 merges the two sets of singular values together into a single",
     "sorted set.  Then it tries to deflate the size of the problem.",
     "There are two ways in which deflation can occur:  when two or more",
     "singular values are close together or if there is a tiny entry in the",
     "Z vector.  For each such occurrence the order of the related secular",
     "equation problem is reduced by one.",
     "SLASD2 is called from SLASD1."],
   "param"=>
    {"NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block.  NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block.  NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has N = NL + NR + 1 rows and",
       "        M = N + SQRE >= N columns."],
     "K"=>
      ["[out]",
       "         K is INTEGER",
       "        Contains the dimension of the non-deflated matrix,",
       "        This is the order of the related secular equation. 1 <= K <=N."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry D contains the singular values of the two submatrices",
       "        to be combined.  On exit D contains the trailing (N-K) updated",
       "        singular values (those which were deflated) sorted into",
       "        increasing order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (N)",
       "        On exit Z contains the updating row vector in the secular",
       "        equation."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "        Contains the diagonal element associated with the added row."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL",
       "        Contains the off-diagonal element associated with the added",
       "        row."],
     "U"=>
      ["[in,out]",
       "         U is REAL array, dimension (LDU,N)",
       "        On entry U contains the left singular vectors of two",
       "        submatrices in the two square blocks with corners at (1,1),",
       "        (NL, NL), and (NL+2, NL+2), (N,N).",
       "        On exit U contains the trailing (N-K) updated left singular",
       "        vectors (those which were deflated) in its last N-K columns."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "        The leading dimension of the array U.  LDU >= N."],
     "VT"=>
      ["[in,out]",
       "         VT is REAL array, dimension (LDVT,M)",
       "        On entry VT**T contains the right singular vectors of two",
       "        submatrices in the two square blocks with corners at (1,1),",
       "        (NL+1, NL+1), and (NL+2, NL+2), (M,M).",
       "        On exit VT**T contains the trailing (N-K) updated right singular",
       "        vectors (those which were deflated) in its last N-K columns.",
       "        In case SQRE =1, the last row of VT spans the right null",
       "        space."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "        The leading dimension of the array VT.  LDVT >= M."],
     "DSIGMA"=>
      ["[out]",
       "         DSIGMA is REAL array, dimension (N)",
       "        Contains a copy of the diagonal elements (K-1 singular values",
       "        and one zero) in the secular equation."],
     "U2"=>
      ["[out]",
       "         U2 is REAL array, dimension (LDU2,N)",
       "        Contains a copy of the first K-1 left singular vectors which",
       "        will be used by SLASD3 in a matrix multiply (SGEMM) to solve",
       "        for the new left singular vectors. U2 is arranged into four",
       "        blocks. The first block contains a column with 1 at NL+1 and",
       "        zero everywhere else; the second block contains non-zero",
       "        entries only at and above NL; the third contains non-zero",
       "        entries only below NL+1; and the fourth is dense."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "        The leading dimension of the array U2.  LDU2 >= N."],
     "VT2"=>
      ["[out]",
       "         VT2 is REAL array, dimension (LDVT2,N)",
       "        VT2**T contains a copy of the first K right singular vectors",
       "        which will be used by SLASD3 in a matrix multiply (SGEMM) to",
       "        solve for the new right singular vectors. VT2 is arranged into",
       "        three blocks. The first block contains a row that corresponds",
       "        to the special 0 diagonal element in SIGMA; the second block",
       "        contains non-zeros only at and before NL +1; the third block",
       "        contains non-zeros only at and after  NL +2."],
     "LDVT2"=>
      ["[in]",
       "         LDVT2 is INTEGER",
       "        The leading dimension of the array VT2.  LDVT2 >= M."],
     "IDXP"=>
      ["[out]",
       "         IDXP is INTEGER array, dimension (N)",
       "        This will contain the permutation used to place deflated",
       "        values of D at the end of the array. On output IDXP(2:K)",
       "        points to the nondeflated D-values and IDXP(K+1:N)",
       "        points to the deflated singular values."],
     "IDX"=>
      ["[out]",
       "         IDX is INTEGER array, dimension (N)",
       "        This will contain the permutation used to sort the contents of",
       "        D into ascending order."],
     "IDXC"=>
      ["[out]",
       "         IDXC is INTEGER array, dimension (N)",
       "        This will contain the permutation used to arrange the columns",
       "        of the deflated U matrix into three groups:  the first group",
       "        contains non-zero entries only at and above NL, the second",
       "        contains non-zero entries only below NL+2, and the third is",
       "        dense."],
     "IDXQ"=>
      ["[in,out]",
       "         IDXQ is INTEGER array, dimension (N)",
       "        This contains the permutation which separately sorts the two",
       "        sub-problems in D into ascending order.  Note that entries in",
       "        the first hlaf of this permutation must first be moved one",
       "        position backward; and entries in the second half",
       "        must first have NL+1 added to their values."],
     "COLTYP"=>
      ["[out]",
       "         COLTYP is INTEGER array, dimension (N)",
       "        As workspace, this will contain a label which will indicate",
       "        which of the following types a column in the U2 matrix or a",
       "        row in the VT2 matrix is:",
       "        1 : non-zero in the upper half only",
       "        2 : non-zero in the lower half only",
       "        3 : dense",
       "        4 : deflated",
       "        On exit, it is an array of dimension 4, with COLTYP(I) being",
       "        the dimension of the I-th type columns."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "stfttr"=>
  {"summary"=>
    ["STFTTR copies a triangular matrix A from rectangular full packed",
     "format (TF) to standard full format (TR)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF is in Normal format;",
       "         = 'T':  ARF is in Transpose format."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices ARF and A. N >= 0."],
     "ARF"=>
      ["[in]",
       "         ARF is REAL array, dimension (N*(N+1)/2).",
       "         On entry, the upper (if UPLO = 'U') or lower (if UPLO = 'L')",
       "         matrix A in RFP format. See the \"Notes\" below for more",
       "         details."],
     "A"=>
      ["[out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On exit, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgeqr2p"=>
  {"summary"=>
    ["ZGEQR2P computes a QR factorization of a complex m by n matrix A:",
     "A = Q * R. The diagonal entries of R are real and nonnegative."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(m,n) by n upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n). The diagonal entries of R",
       "         are real and nonnegative; the elements below the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "slarnv"=>
  {"summary"=>
    ["SLARNV returns a vector of n random real numbers from a uniform or",
     "normal distribution."],
   "param"=>
    {"IDIST"=>
      ["[in]",
       "         IDIST is INTEGER",
       "         Specifies the distribution of the random numbers:",
       "         = 1:  uniform (0,1)",
       "         = 2:  uniform (-1,1)",
       "         = 3:  normal (0,1)"],
     "ISEED"=>
      ["[in,out]",
       "         ISEED is INTEGER array, dimension (4)",
       "         On entry, the seed of the random number generator; the array",
       "         elements must be between 0 and 4095, and ISEED(4) must be",
       "         odd.",
       "         On exit, the seed is updated."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of random numbers to be generated."],
     "X"=>
      ["[out]",
       "         X is REAL array, dimension (N)",
       "         The generated random numbers."]}},
 "dpbcon"=>
  {"summary"=>
    ["DPBCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric positive definite band matrix using the",
     "Cholesky factorization A = U**T*U or A = L*L**T computed by DPBTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor stored in AB;",
       "         = 'L':  Lower triangular factor stored in AB."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T of the band matrix A, stored in the",
       "         first KD+1 rows of the array.  The j-th column of U or L is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO ='U', AB(kd+1+i-j,j) = U(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO ='L', AB(1+i-j,j)    = L(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm (or infinity-norm) of the symmetric band matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zsysv_rk"=>
  {"summary"=>
    ["ZSYSV_RK computes the solution to a complex system of linear",
     "equations A * X = B, where A is an N-by-N symmetric matrix",
     "and X and B are N-by-NRHS matrices.",
     "The bounded Bunch-Kaufman (rook) diagonal pivoting method is used",
     "to factor A as",
     "   A = P*U*D*(U**T)*(P**T),  if UPLO = 'U', or",
     "   A = P*L*D*(L**T)*(P**T),  if UPLO = 'L',",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "ZSYTRF_RK is called to compute the factorization of a complex",
     "symmetric matrix.  The factored form of A is then used to solve",
     "the system of equations A * X = B by calling BLAS3 routine ZSYTRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, if INFO = 0, diagonal of the block diagonal",
       "         matrix D and factors U or L  as computed by ZSYTRF_RK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         For more info see the description of ZSYTRF_RK routine."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On exit, contains the output computed by the factorization",
       "         routine ZSYTRF_RK, i.e. the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases.",
       "         For more info see the description of ZSYTRF_RK routine."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D,",
       "         as determined by ZSYTRF_RK.",
       "         For more info see the description of ZSYTRF_RK routine."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension ( MAX(1,LWORK) ).",
       "         Work array used in the factorization stage.",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1. For best performance",
       "         of factorization stage LWORK >= max(1,N*NB), where NB is",
       "         the optimal blocksize for ZSYTRF_RK.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array for factorization stage, returns this value as",
       "         the first entry of the WORK array, and no error message",
       "         related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "dsygvd"=>
  {"summary"=>
    ["DSYGVD computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be symmetric and B is also positive definite.",
     "If eigenvectors are desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the symmetric matrix B.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of B contains the",
       "         upper triangular part of the matrix B.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of B contains",
       "         the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LWORK >= 2*N+1.",
       "         If JOBZ = 'V' and N > 1, LWORK >= 1 + 6*N + 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK >= 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK >= 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  DPOTRF or DSYEVD returned an error code:",
       "            <= N:  if INFO = i and JOBZ = 'N', then the algorithm",
       "                   failed to converge; i off-diagonal elements of an",
       "                   intermediate tridiagonal form did not converge to",
       "                   zero;",
       "                   if INFO = i and JOBZ = 'V', then the algorithm",
       "                   failed to compute an eigenvalue while working on",
       "                   the submatrix lying in rows and columns INFO/(N+1)",
       "                   through mod(INFO,N+1);",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "slasq1"=>
  {"summary"=>
    ["SLASQ1 computes the singular values of a real N-by-N bidiagonal",
     "matrix with diagonal D and off-diagonal E. The singular values",
     "are computed to high relative accuracy, in the absence of",
     "denormalization, underflow and overflow. The algorithm was first",
     "presented in",
     "\"Accurate singular values and differential qd algorithms\" by K. V.",
     "Fernando and B. N. Parlett, Numer. Math., Vol-67, No. 2, pp. 191-230,",
     "1994,",
     "and the present implementation is described in \"An implementation of",
     "the dqds Algorithm (Positive Case)\", LAPACK Working Note."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "       The number of rows and columns in the matrix. N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "       On entry, D contains the diagonal elements of the",
       "       bidiagonal matrix whose SVD is desired. On normal exit,",
       "       D contains the singular values in decreasing order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N)",
       "       On entry, elements E(1:N-1) contain the off-diagonal elements",
       "       of the bidiagonal matrix whose SVD is desired.",
       "       On exit, E is overwritten."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "       = 0: successful exit",
       "       < 0: if INFO = -i, the i-th argument had an illegal value",
       "       > 0: the algorithm failed",
       "            = 1, a split was marked by a positive value in E",
       "            = 2, current block of Z not diagonalized after 100*N",
       "                 iterations (in inner while loop)  On exit D and E",
       "                 represent a matrix with the same singular values",
       "                 which the calling subroutine could use to finish the",
       "                 computation, or even feed back into SLASQ1",
       "            = 3, termination criterion of outer while loop not met",
       "                 (program created more than N unreduced blocks)"]}},
 "dsysvx"=>
  {"summary"=>
    ["DSYSVX uses the diagonal pivoting factorization to compute the",
     "solution to a real system of linear equations A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "cgbrfsx"=>
  {"summary"=>
    ["   CGBRFSX improves the computed solution to a system of linear",
     "   equations and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED, R",
     "   and C below. In this case, the solution and error bounds returned",
     "   are for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "              diag(R).",
       "      = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "              by diag(C).",
       "      = 'B':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(R) * A * diag(C).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "    The original band matrix A, stored in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by DGBTRF.  U is stored as an upper triangular band",
       "    matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "    the multipliers used during the factorization are stored in",
       "    rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL*KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from SGETRF; for 1<=i<=N, row i of the",
       "    matrix was interchanged with row IPIV(i)."],
     "R"=>
      ["[in,out]",
       "         R is REAL array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'R' or 'B', A is",
       "    multiplied on the left by diag(R); if EQUED = 'N' or 'C', R",
       "    is not accessed.  R is an input argument if FACT = 'F';",
       "    otherwise, R is an output argument.  If FACT = 'F' and",
       "    EQUED = 'R' or 'B', each element of R must be positive.",
       "    If R is output, each element of R is a power of the radix.",
       "    If R is input, each element of R should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A.  If EQUED = 'C' or 'B', A is",
       "    multiplied on the right by diag(C); if EQUED = 'N' or 'R', C",
       "    is not accessed.  C is an input argument if FACT = 'F';",
       "    otherwise, C is an output argument.  If FACT = 'F' and",
       "    EQUED = 'C' or 'B', each element of C must be positive.",
       "    If C is output, each element of C is a power of the radix.",
       "    If C is input, each element of C should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by SGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is REAL array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "zsyr"=>
  {"summary"=>
    ["ZSYR   performs the symmetric rank 1 operation",
     "   A := alpha*x*x**H + A,",
     "where alpha is a complex scalar, x is an n element vector and A is an",
     "n by n symmetric matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array A is to be referenced as",
       "          follows:",
       "             UPLO = 'U' or 'u'   Only the upper triangular part of A",
       "                                 is to be referenced.",
       "             UPLO = 'L' or 'l'   Only the lower triangular part of A",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the order of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX*16",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCX ) ).",
       "          Before entry, the incremented array X must contain the N-",
       "          element vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension ( LDA, N )",
       "          Before entry, with  UPLO = 'U' or 'u', the leading n by n",
       "          upper triangular part of the array A must contain the upper",
       "          triangular part of the symmetric matrix and the strictly",
       "          lower triangular part of A is not referenced. On exit, the",
       "          upper triangular part of the array A is overwritten by the",
       "          upper triangular part of the updated matrix.",
       "          Before entry, with UPLO = 'L' or 'l', the leading n by n",
       "          lower triangular part of the array A must contain the lower",
       "          triangular part of the symmetric matrix and the strictly",
       "          upper triangular part of A is not referenced. On exit, the",
       "          lower triangular part of the array A is overwritten by the",
       "          lower triangular part of the updated matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, N ).",
       "          Unchanged on exit."]}},
 "sgesv"=>
  {"summary"=>
    ["SGESV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N matrix and X and B are N-by-NRHS matrices.",
     "The LU decomposition with partial pivoting and row interchanges is",
     "used to factor A as",
     "   A = P * L * U,",
     "where P is a permutation matrix, L is unit lower triangular, and U is",
     "upper triangular.  The factored form of A is then used to solve the",
     "system of equations A * X = B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the N-by-N coefficient matrix A.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices that define the permutation matrix P;",
       "         row i of the matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS matrix of right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero.  The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, so the solution could not be computed."]}},
 "xerbla"=>
  {"summary"=>
    ["XERBLA  is an error handler for the LAPACK routines.",
     "It is called by an LAPACK routine if an input parameter has an",
     "invalid value.  A message is printed and execution stops.",
     "Installers may consider modifying the STOP statement in order to",
     "call system-specific exception-handling facilities."],
   "param"=>
    {"SRNAME"=>
      ["[in]",
       "         SRNAME is CHARACTER*(*)",
       "         The name of the routine which called XERBLA."],
     "INFO"=>
      ["[in]",
       "         INFO is INTEGER",
       "         The position of the invalid parameter in the parameter list",
       "         of the calling routine."]}},
 "sggsvp3"=>
  {"summary"=>
    ["SGGSVP3 computes orthogonal matrices U, V and Q such that",
     "                   N-K-L  K    L",
     " U**T*A*Q =     K ( 0    A12  A13 )  if M-K-L >= 0;",
     "                L ( 0     0   A23 )",
     "            M-K-L ( 0     0    0  )",
     "                 N-K-L  K    L",
     "        =     K ( 0    A12  A13 )  if M-K-L < 0;",
     "            M-K ( 0     0   A23 )",
     "                 N-K-L  K    L",
     " V**T*B*Q =   L ( 0     0   B13 )",
     "            P-L ( 0     0    0  )",
     "where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular",
     "upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,",
     "otherwise A23 is (M-K)-by-L upper trapezoidal.  K+L = the effective",
     "numerical rank of the (M+P)-by-N matrix (A**T,B**T)**T.",
     "This decomposition is the preprocessing step for computing the",
     "Generalized Singular Value Decomposition (GSVD), see subroutine",
     "SGGSVD3."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  Orthogonal matrix U is computed;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  Orthogonal matrix V is computed;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Orthogonal matrix Q is computed;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A contains the triangular (or trapezoidal) matrix",
       "         described in the Purpose section."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, B contains the triangular matrix described in",
       "         the Purpose section."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TOLA"=>["[in]", "         TOLA is REAL"],
     "TOLB"=>
      ["[in]",
       "         TOLB is REAL",
       "         TOLA and TOLB are the thresholds to determine the effective",
       "         numerical rank of matrix B and a subblock of A. Generally,",
       "         they are set to",
       "            TOLA = MAX(M,N)*norm(A)*MACHEPS,",
       "            TOLB = MAX(P,N)*norm(B)*MACHEPS.",
       "         The size of TOLA and TOLB may affect the size of backward",
       "         errors of the decomposition."],
     "K"=>["[out]", "         K is INTEGER"],
     "L"=>
      ["[out]",
       "         L is INTEGER",
       "         On exit, K and L specify the dimension of the subblocks",
       "         described in Purpose section.",
       "         K + L = effective numerical rank of (A**T,B**T)**T."],
     "U"=>
      ["[out]",
       "         U is REAL array, dimension (LDU,M)",
       "         If JOBU = 'U', U contains the orthogonal matrix U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[out]",
       "         V is REAL array, dimension (LDV,P)",
       "         If JOBV = 'V', V contains the orthogonal matrix V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "         If JOBQ = 'Q', Q contains the orthogonal matrix Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "TAU"=>["[out]", "         TAU is REAL array, dimension (N)"],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "cgtts2"=>
  {"summary"=>
    ["CGTTS2 solves one of the systems of equations",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B,",
     "with a tridiagonal matrix A using the LU factorization computed",
     "by CGTTRF."],
   "param"=>
    {"ITRANS"=>
      ["[in]",
       "         ITRANS is INTEGER",
       "         Specifies the form of the system of equations.",
       "         = 0:  A * X = B     (No transpose)",
       "         = 1:  A**T * X = B  (Transpose)",
       "         = 2:  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A."],
     "D"=>
      ["[in]",
       "         D is COMPLEX array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX array, dimension (N-1)",
       "         The (n-1) elements of the first super-diagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is COMPLEX array, dimension (N-2)",
       "         The (n-2) elements of the second super-diagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the matrix of right hand side vectors B.",
       "         On exit, B is overwritten by the solution vectors X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."]}},
 "dlarscl2"=>
  {"summary"=>
    ["DLARSCL2 performs a reciprocal diagonal scaling on an vector:",
     "  x <-- inv(D) * x",
     "where the diagonal matrix D is stored as a vector.",
     "Eventually to be replaced by BLAS_dge_diag_scale in the new BLAS",
     "standard."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "    The number of rows of D and X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of columns of X. N >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (M)",
       "    Diagonal matrix D, stored as a vector of length M."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,N)",
       "    On entry, the vector X to be scaled by D.",
       "    On exit, the scaled vector."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the vector X. LDX >= M."]}},
 "zhecon"=>
  {"summary"=>
    ["ZHECON estimates the reciprocal of the condition number of a complex",
     "Hermitian matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by ZHETRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZHETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHETRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhetrf"=>
  {"summary"=>
    ["ZHETRF computes the factorization of a complex Hermitian matrix A",
     "using the Bunch-Kaufman diagonal pivoting method.  The form of the",
     "factorization is",
     "   A = U*D*U**H  or  A = L*D*L**H",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is Hermitian and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "dlarz"=>
  {"summary"=>
    ["DLARZ applies a real elementary reflector H to a real M-by-N",
     "matrix C, from either the left or the right. H is represented in the",
     "form",
     "      H = I - tau * v * v**T",
     "where tau is a real scalar and v is a real vector.",
     "If tau = 0, then H is taken to be the unit matrix.",
     "H is a product of k elementary reflectors as returned by DTZRZF."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of entries of the vector V containing",
       "         the meaningful part of the Householder vectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension (1+(L-1)*abs(INCV))",
       "         The vector v in the representation of H as returned by",
       "         DTZRZF. V is not used if TAU = 0."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between elements of v. INCV <> 0."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension",
       "                        (N) if SIDE = 'L'",
       "                     or (M) if SIDE = 'R'"]}},
 "stbrfs"=>
  {"summary"=>
    ["STBRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular band",
     "coefficient matrix.",
     "The solution matrix X must be computed by STBTRS or some other",
     "means before entering this routine.  STBRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cla_porfsx_extended"=>
  {"summary"=>
    ["CLA_PORFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by CPORFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by CPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension",
       "                   (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by CPOTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is REAL array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by CLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is REAL array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is REAL array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]", "         AYB is REAL array, dimension (N)", "    Workspace."],
     "DY"=>
      ["[in]",
       "         DY is COMPLEX array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is COMPLEX array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is REAL",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is REAL",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to CPOTRS had an illegal",
       "            value"]}},
 "zlacgv"=>
  {"summary"=>["ZLACGV conjugates a complex vector of length N."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The length of the vector X.  N >= 0."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension",
       "                        (1+(N-1)*abs(INCX))",
       "         On entry, the vector of length N to be conjugated.",
       "         On exit, X is overwritten with conjg(X)."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The spacing between successive elements of X."]}},
 "chetri2x"=>
  {"summary"=>
    ["CHETRI2X computes the inverse of a complex Hermitian indefinite matrix",
     "A using the factorization A = U*D*U**H or A = L*D*L**H computed by",
     "CHETRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the NNB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CHETRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NNB structure of D",
       "         as determined by CHETRF."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX array, dimension (N+NB+1,NB+3)"],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "sgelqf"=>
  {"summary"=>
    ["SGELQF computes an LQ factorization of a real M-by-N matrix A:",
     "A = L * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the m-by-min(m,n) lower trapezoidal matrix L (L is",
       "         lower triangular if m <= n); the elements above the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dporfs"=>
  {"summary"=>
    ["DPORFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric positive definite,",
     "and provides error bounds and backward error estimates for the",
     "solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, as computed by DPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by DPOTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chpcon"=>
  {"summary"=>
    ["CHPCON estimates the reciprocal of the condition number of a complex",
     "Hermitian packed matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by CHPTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CHPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHPTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "drscl"=>
  {"summary"=>
    ["DRSCL multiplies an n-element real vector x by the real scalar 1/a.",
     "This is done without overflow or underflow as long as",
     "the final result x/a does not overflow or underflow."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of components of the vector x."],
     "SA"=>
      ["[in]",
       "         SA is DOUBLE PRECISION",
       "         The scalar a which is used to divide each component of x.",
       "         SA must be >= 0, or the subroutine will divide by zero."],
     "SX"=>
      ["[in,out]",
       "         SX is DOUBLE PRECISION array, dimension",
       "                        (1+(N-1)*abs(INCX))",
       "         The n-element vector x."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of the vector SX.",
       "         > 0:  SX(1) = X(1) and SX(1+(i-1)*INCX) = x(i),     1< i<= n"]}},
 "csysvx"=>
  {"summary"=>
    ["CSYSVX uses the diagonal pivoting factorization to compute the",
     "solution to a complex system of linear equations A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "csrscl"=>
  {"summary"=>
    ["CSRSCL multiplies an n-element complex vector x by the real scalar",
     "1/a.  This is done without overflow or underflow as long as",
     "the final result x/a does not overflow or underflow."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of components of the vector x."],
     "SA"=>
      ["[in]",
       "         SA is REAL",
       "         The scalar a which is used to divide each component of x.",
       "         SA must be >= 0, or the subroutine will divide by zero."],
     "SX"=>
      ["[in,out]",
       "         SX is COMPLEX array, dimension",
       "                        (1+(N-1)*abs(INCX))",
       "         The n-element vector x."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of the vector SX.",
       "         > 0:  SX(1) = X(1) and SX(1+(i-1)*INCX) = x(i),     1< i<= n"]}},
 "dsprfs"=>
  {"summary"=>
    ["DSPRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric indefinite",
     "and packed, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n."],
     "AFP"=>
      ["[in]",
       "         AFP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The factored form of the matrix A.  AFP contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**T or",
       "         A = L*D*L**T as computed by DSPTRF, stored as a packed",
       "         triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSPTRF."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by DSPTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cunml2"=>
  {"summary"=>
    ["CUNML2 overwrites the general complex m-by-n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**H* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**H if SIDE = 'R' and TRANS = 'C',",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k)**H . . . H(2)**H H(1)**H",
     "as returned by CGELQF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left",
       "         = 'R': apply Q or Q**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGELQF in the first k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGELQF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dlasd7"=>
  {"summary"=>
    ["DLASD7 merges the two sets of singular values together into a single",
     "sorted set. Then it tries to deflate the size of the problem. There",
     "are two ways in which deflation can occur:  when two or more singular",
     "values are close together or if there is a tiny entry in the Z",
     "vector. For each such occurrence the order of the related",
     "secular equation problem is reduced by one.",
     "DLASD7 is called from DLASD6."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "         Specifies whether singular vectors are to be computed",
       "         in compact form, as follows:",
       "         = 0: Compute singular values only.",
       "         = 1: Compute singular vectors of upper",
       "              bidiagonal matrix in compact form."],
     "NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block. NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block. NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has",
       "        N = NL + NR + 1 rows and",
       "        M = N + SQRE >= N columns."],
     "K"=>
      ["[out]",
       "         K is INTEGER",
       "        Contains the dimension of the non-deflated matrix, this is",
       "        the order of the related secular equation. 1 <= K <=N."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension ( N )",
       "        On entry D contains the singular values of the two submatrices",
       "        to be combined. On exit D contains the trailing (N-K) updated",
       "        singular values (those which were deflated) sorted into",
       "        increasing order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension ( M )",
       "        On exit Z contains the updating row vector in the secular",
       "        equation."],
     "ZW"=>
      ["[out]",
       "         ZW is DOUBLE PRECISION array, dimension ( M )",
       "        Workspace for Z."],
     "VF"=>
      ["[in,out]",
       "         VF is DOUBLE PRECISION array, dimension ( M )",
       "        On entry, VF(1:NL+1) contains the first components of all",
       "        right singular vectors of the upper block; and VF(NL+2:M)",
       "        contains the first components of all right singular vectors",
       "        of the lower block. On exit, VF contains the first components",
       "        of all right singular vectors of the bidiagonal matrix."],
     "VFW"=>
      ["[out]",
       "         VFW is DOUBLE PRECISION array, dimension ( M )",
       "        Workspace for VF."],
     "VL"=>
      ["[in,out]",
       "         VL is DOUBLE PRECISION array, dimension ( M )",
       "        On entry, VL(1:NL+1) contains the  last components of all",
       "        right singular vectors of the upper block; and VL(NL+2:M)",
       "        contains the last components of all right singular vectors",
       "        of the lower block. On exit, VL contains the last components",
       "        of all right singular vectors of the bidiagonal matrix."],
     "VLW"=>
      ["[out]",
       "         VLW is DOUBLE PRECISION array, dimension ( M )",
       "        Workspace for VL."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "        Contains the diagonal element associated with the added row."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION",
       "        Contains the off-diagonal element associated with the added",
       "        row."],
     "DSIGMA"=>
      ["[out]",
       "         DSIGMA is DOUBLE PRECISION array, dimension ( N )",
       "        Contains a copy of the diagonal elements (K-1 singular values",
       "        and one zero) in the secular equation."],
     "IDX"=>
      ["[out]",
       "         IDX is INTEGER array, dimension ( N )",
       "        This will contain the permutation used to sort the contents of",
       "        D into ascending order."],
     "IDXP"=>
      ["[out]",
       "         IDXP is INTEGER array, dimension ( N )",
       "        This will contain the permutation used to place deflated",
       "        values of D at the end of the array. On output IDXP(2:K)",
       "        points to the nondeflated D-values and IDXP(K+1:N)",
       "        points to the deflated singular values."],
     "IDXQ"=>
      ["[in]",
       "         IDXQ is INTEGER array, dimension ( N )",
       "        This contains the permutation which separately sorts the two",
       "        sub-problems in D into ascending order.  Note that entries in",
       "        the first half of this permutation must first be moved one",
       "        position backward; and entries in the second half",
       "        must first have NL+1 added to their values."],
     "PERM"=>
      ["[out]",
       "         PERM is INTEGER array, dimension ( N )",
       "        The permutations (from deflation and sorting) to be applied",
       "        to each singular block. Not referenced if ICOMPQ = 0."],
     "GIVPTR"=>
      ["[out]",
       "         GIVPTR is INTEGER",
       "        The number of Givens rotations which took place in this",
       "        subproblem. Not referenced if ICOMPQ = 0."],
     "GIVCOL"=>
      ["[out]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation. Not referenced if ICOMPQ = 0."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER",
       "        The leading dimension of GIVCOL, must be at least N."],
     "GIVNUM"=>
      ["[out]",
       "         GIVNUM is DOUBLE PRECISION array, dimension ( LDGNUM, 2 )",
       "        Each number indicates the C or S value to be used in the",
       "        corresponding Givens rotation. Not referenced if ICOMPQ = 0."],
     "LDGNUM"=>
      ["[in]",
       "         LDGNUM is INTEGER",
       "        The leading dimension of GIVNUM, must be at least N."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION",
       "        C contains garbage if SQRE =0 and the C-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION",
       "        S contains garbage if SQRE =0 and the S-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit.",
       "        < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "sggsvd3"=>
  {"summary"=>
    ["SGGSVD3 computes the generalized singular value decomposition (GSVD)",
     "of an M-by-N real matrix A and P-by-N real matrix B:",
     "      U**T*A*Q = D1*( 0 R ),    V**T*B*Q = D2*( 0 R )",
     "where U, V and Q are orthogonal matrices.",
     "Let K+L = the effective numerical rank of the matrix (A**T,B**T)**T,",
     "then R is a K+L-by-K+L nonsingular upper triangular matrix, D1 and",
     "D2 are M-by-(K+L) and P-by-(K+L) \"diagonal\" matrices and of the",
     "following structures, respectively:",
     "If M-K-L >= 0,",
     "                    K  L",
     "       D1 =     K ( I  0 )",
     "                L ( 0  C )",
     "            M-K-L ( 0  0 )",
     "                  K  L",
     "       D2 =   L ( 0  S )",
     "            P-L ( 0  0 )",
     "                N-K-L  K    L",
     "  ( 0 R ) = K (  0   R11  R12 )",
     "            L (  0    0   R22 )",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(K+L) ),",
     "  S = diag( BETA(K+1),  ... , BETA(K+L) ),",
     "  C**2 + S**2 = I.",
     "  R is stored in A(1:K+L,N-K-L+1:N) on exit.",
     "If M-K-L < 0,",
     "                  K M-K K+L-M",
     "       D1 =   K ( I  0    0   )",
     "            M-K ( 0  C    0   )",
     "                    K M-K K+L-M",
     "       D2 =   M-K ( 0  S    0  )",
     "            K+L-M ( 0  0    I  )",
     "              P-L ( 0  0    0  )",
     "                   N-K-L  K   M-K  K+L-M",
     "  ( 0 R ) =     K ( 0    R11  R12  R13  )",
     "              M-K ( 0     0   R22  R23  )",
     "            K+L-M ( 0     0    0   R33  )",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(M) ),",
     "  S = diag( BETA(K+1),  ... , BETA(M) ),",
     "  C**2 + S**2 = I.",
     "  (R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N), and R33 is stored",
     "  ( 0  R22 R23 )",
     "  in B(M-K+1:L,N+M-K-L+1:N) on exit.",
     "The routine computes C, S, R, and optionally the orthogonal",
     "transformation matrices U, V and Q.",
     "In particular, if B is an N-by-N nonsingular matrix, then the GSVD of",
     "A and B implicitly gives the SVD of A*inv(B):",
     "                     A*inv(B) = U*(D1*inv(D2))*V**T.",
     "If ( A**T,B**T)**T  has orthonormal columns, then the GSVD of A and B is",
     "also equal to the CS decomposition of A and B. Furthermore, the GSVD",
     "can be used to derive the solution of the eigenvalue problem:",
     "                     A**T*A x = lambda* B**T*B x.",
     "In some literature, the GSVD of A and B is presented in the form",
     "                 U**T*A*X = ( 0 D1 ),   V**T*B*X = ( 0 D2 )",
     "where U and V are orthogonal and X is nonsingular, D1 and D2 are",
     "``diagonal''.  The former GSVD form can be converted to the latter",
     "form by taking the nonsingular matrix X as",
     "                     X = Q*( I   0    )",
     "                           ( 0 inv(R) )."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  Orthogonal matrix U is computed;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  Orthogonal matrix V is computed;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Orthogonal matrix Q is computed;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "K"=>["[out]", "         K is INTEGER"],
     "L"=>
      ["[out]",
       "         L is INTEGER",
       "         On exit, K and L specify the dimension of the subblocks",
       "         described in Purpose.",
       "         K + L = effective numerical rank of (A**T,B**T)**T."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A contains the triangular matrix R, or part of R.",
       "         See Purpose for details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, B contains the triangular matrix R if M-K-L < 0.",
       "         See Purpose for details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "ALPHA"=>["[out]", "         ALPHA is REAL array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         On exit, ALPHA and BETA contain the generalized singular",
       "         value pairs of A and B;",
       "           ALPHA(1:K) = 1,",
       "           BETA(1:K)  = 0,",
       "         and if M-K-L >= 0,",
       "           ALPHA(K+1:K+L) = C,",
       "           BETA(K+1:K+L)  = S,",
       "         or if M-K-L < 0,",
       "           ALPHA(K+1:M)=C, ALPHA(M+1:K+L)=0",
       "           BETA(K+1:M) =S, BETA(M+1:K+L) =1",
       "         and",
       "           ALPHA(K+L+1:N) = 0",
       "           BETA(K+L+1:N)  = 0"],
     "U"=>
      ["[out]",
       "         U is REAL array, dimension (LDU,M)",
       "         If JOBU = 'U', U contains the M-by-M orthogonal matrix U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[out]",
       "         V is REAL array, dimension (LDV,P)",
       "         If JOBV = 'V', V contains the P-by-P orthogonal matrix V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "         If JOBQ = 'Q', Q contains the N-by-N orthogonal matrix Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N)",
       "         On exit, IWORK stores the sorting information. More",
       "         precisely, the following loop will sort ALPHA",
       "            for I = K+1, min(M,K+L)",
       "                swap ALPHA(I) and ALPHA(IWORK(I))",
       "            endfor",
       "         such that ALPHA(1) >= ALPHA(2) >= ... >= ALPHA(N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, the Jacobi-type procedure failed to",
       "               converge.  For further details, see subroutine STGSJA."]}},
 "cstein"=>
  {"summary"=>
    ["CSTEIN computes the eigenvectors of a real symmetric tridiagonal",
     "matrix T corresponding to specified eigenvalues, using inverse",
     "iteration.",
     "The maximum number of iterations allowed for each eigenvector is",
     "specified by an internal parameter MAXITS (currently set to 5).",
     "Although the eigenvectors are real, they are stored in a complex",
     "array, which may be passed to CUNMTR or CUPMTR for back",
     "transformation to the eigenvectors of a complex Hermitian matrix",
     "which was reduced to tridiagonal form."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the tridiagonal matrix",
       "         T, stored in elements 1 to N-1."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of eigenvectors to be found.  0 <= M <= N."],
     "W"=>
      ["[in]",
       "         W is REAL array, dimension (N)",
       "         The first M elements of W contain the eigenvalues for",
       "         which eigenvectors are to be computed.  The eigenvalues",
       "         should be grouped by split-off block and ordered from",
       "         smallest to largest within the block.  ( The output array",
       "         W from SSTEBZ with ORDER = 'B' is expected here. )"],
     "IBLOCK"=>
      ["[in]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         The submatrix indices associated with the corresponding",
       "         eigenvalues in W; IBLOCK(i)=1 if eigenvalue W(i) belongs to",
       "         the first submatrix from the top, =2 if W(i) belongs to",
       "         the second submatrix, etc.  ( The output array IBLOCK",
       "         from SSTEBZ is expected here. )"],
     "ISPLIT"=>
      ["[in]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into submatrices.",
       "         The first submatrix consists of rows/columns 1 to",
       "         ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1",
       "         through ISPLIT( 2 ), etc.",
       "         ( The output array ISPLIT from SSTEBZ is expected here. )"],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, M)",
       "         The computed eigenvectors.  The eigenvector associated",
       "         with the eigenvalue W(i) is stored in the i-th column of",
       "         Z.  Any vector which fails to converge is set to its current",
       "         iterate after MAXITS iterations.",
       "         The imaginary parts of the eigenvectors are set to zero."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (5*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (M)",
       "         On normal exit, all elements of IFAIL are zero.",
       "         If one or more eigenvectors fail to converge after",
       "         MAXITS iterations, then their indices are stored in",
       "         array IFAIL."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, then i eigenvectors failed to converge",
       "              in MAXITS iterations.  Their indices are stored in",
       "              array IFAIL."]}},
 "sorgr2"=>
  {"summary"=>
    ["SORGR2 generates an m by n real matrix Q with orthonormal rows,",
     "which is defined as the last m rows of a product of k elementary",
     "reflectors of order n",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by SGERQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the (m-k+i)-th row must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by SGERQF in the last k rows of its array argument",
       "         A.",
       "         On exit, the m by n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGERQF."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "zla_herpvgrw"=>
  {"summary"=>
    ["ZLA_HERPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "INFO"=>
      ["[in]",
       "         INFO is INTEGER",
       "    The value of INFO returned from ZHETRF, .i.e., the pivot in",
       "    column INFO is exactly 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by ZHETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by ZHETRF."],
     "WORK"=>
      ["[in]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"]}},
 "ssprfs"=>
  {"summary"=>
    ["SSPRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric indefinite",
     "and packed, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n."],
     "AFP"=>
      ["[in]",
       "         AFP is REAL array, dimension (N*(N+1)/2)",
       "         The factored form of the matrix A.  AFP contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**T or",
       "         A = L*D*L**T as computed by SSPTRF, stored as a packed",
       "         triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSPTRF."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by SSPTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaed9"=>
  {"summary"=>
    ["DLAED9 finds the roots of the secular equation, as defined by the",
     "values in D, Z, and RHO, between KSTART and KSTOP.  It makes the",
     "appropriate calls to DLAED4 and then stores the new matrix of",
     "eigenvectors for use in calculating the next level of Z vectors."],
   "param"=>
    {"K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of terms in the rational function to be solved by",
       "         DLAED4.  K >= 0."],
     "KSTART"=>["[in]", "         KSTART is INTEGER"],
     "KSTOP"=>
      ["[in]",
       "         KSTOP is INTEGER",
       "         The updated eigenvalues Lambda(I), KSTART <= I <= KSTOP",
       "         are to be computed.  1 <= KSTART <= KSTOP <= K."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows and columns in the Q matrix.",
       "         N >= K (delation may result in N > K)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         D(I) contains the updated eigenvalues",
       "         for KSTART <= I <= KSTOP."],
     "Q"=>["[out]", "         Q is DOUBLE PRECISION array, dimension (LDQ,N)"],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= max( 1, N )."],
     "RHO"=>
      ["[in]",
       "         RHO is DOUBLE PRECISION",
       "         The value of the parameter in the rank one update equation.",
       "         RHO >= 0 required."],
     "DLAMDA"=>
      ["[in]",
       "         DLAMDA is DOUBLE PRECISION array, dimension (K)",
       "         The first K elements of this array contain the old roots",
       "         of the deflated updating problem.  These are the poles",
       "         of the secular equation."],
     "W"=>
      ["[in]",
       "         W is DOUBLE PRECISION array, dimension (K)",
       "         The first K elements of this array contain the components",
       "         of the deflation-adjusted updating vector."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (LDS, K)",
       "         Will contain the eigenvectors of the repaired matrix which",
       "         will be stored for subsequent Z vector calculation and",
       "         multiplied by the previously accumulated eigenvectors",
       "         to update the system."],
     "LDS"=>
      ["[in]",
       "         LDS is INTEGER",
       "         The leading dimension of S.  LDS >= max( 1, K )."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, an eigenvalue did not converge"]}},
 "slaebz"=>
  {"summary"=>
    ["SLAEBZ contains the iteration loops which compute and use the",
     "function N(w), which is the count of eigenvalues of a symmetric",
     "tridiagonal matrix T less than or equal to its argument  w.  It",
     "performs a choice of two types of loops:",
     "IJOB=1, followed by",
     "IJOB=2: It takes as input a list of intervals and returns a list of",
     "        sufficiently small intervals whose union contains the same",
     "        eigenvalues as the union of the original intervals.",
     "        The input intervals are (AB(j,1),AB(j,2)], j=1,...,MINP.",
     "        The output interval (AB(j,1),AB(j,2)] will contain",
     "        eigenvalues NAB(j,1)+1,...,NAB(j,2), where 1 <= j <= MOUT.",
     "IJOB=3: It performs a binary search in each input interval",
     "        (AB(j,1),AB(j,2)] for a point  w(j)  such that",
     "        N(w(j))=NVAL(j), and uses  C(j)  as the starting point of",
     "        the search.  If such a w(j) is found, then on output",
     "        AB(j,1)=AB(j,2)=w.  If no such w(j) is found, then on output",
     "        (AB(j,1),AB(j,2)] will be a small interval containing the",
     "        point where N(w) jumps through NVAL(j), unless that point",
     "        lies outside the initial interval.",
     "Note that the intervals are in all cases half-open intervals,",
     "i.e., of the form  (a,b] , which includes  b  but not  a .",
     "To avoid underflow, the matrix should be scaled so that its largest",
     "element is no greater than  overflow**(1/2) * underflow**(1/4)",
     "in absolute value.  To assure the most accurate computation",
     "of small eigenvalues, the matrix should be scaled to be",
     "not much smaller than that, either.",
     "See W. Kahan \"Accurate Eigenvalues of a Symmetric Tridiagonal",
     "Matrix\", Report CS41, Computer Science Dept., Stanford",
     "University, July 21, 1966",
     "Note: the arguments are, in general, *not* checked for unreasonable",
     "values."],
   "param"=>
    {"IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies what is to be done:",
       "         = 1:  Compute NAB for the initial intervals.",
       "         = 2:  Perform bisection iteration to find eigenvalues of T.",
       "         = 3:  Perform bisection iteration to invert N(w), i.e.,",
       "               to find a point which has a specified number of",
       "               eigenvalues of T to its left.",
       "         Other values will cause SLAEBZ to return with INFO=-1."],
     "NITMAX"=>
      ["[in]",
       "         NITMAX is INTEGER",
       "         The maximum number of \"levels\" of bisection to be",
       "         performed, i.e., an interval of width W will not be made",
       "         smaller than 2^(-NITMAX) * W.  If not all intervals",
       "         have converged after NITMAX iterations, then INFO is set",
       "         to the number of non-converged intervals."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The dimension n of the tridiagonal matrix T.  It must be at",
       "         least 1."],
     "MMAX"=>
      ["[in]",
       "         MMAX is INTEGER",
       "         The maximum number of intervals.  If more than MMAX intervals",
       "         are generated, then SLAEBZ will quit with INFO=MMAX+1."],
     "MINP"=>
      ["[in]",
       "         MINP is INTEGER",
       "         The initial number of intervals.  It may not be greater than",
       "         MMAX."],
     "NBMIN"=>
      ["[in]",
       "         NBMIN is INTEGER",
       "         The smallest number of intervals that should be processed",
       "         using a vector loop.  If zero, then only the scalar loop",
       "         will be used."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The minimum (absolute) width of an interval.  When an",
       "         interval is narrower than ABSTOL, or than RELTOL times the",
       "         larger (in magnitude) endpoint, then it is considered to be",
       "         sufficiently small, i.e., converged.  This must be at least",
       "         zero."],
     "RELTOL"=>
      ["[in]",
       "         RELTOL is REAL",
       "         The minimum relative width of an interval.  When an interval",
       "         is narrower than ABSTOL, or than RELTOL times the larger (in",
       "         magnitude) endpoint, then it is considered to be",
       "         sufficiently small, i.e., converged.  Note: this should",
       "         always be at least radix*machine epsilon."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "         The minimum absolute value of a \"pivot\" in the Sturm",
       "         sequence loop.",
       "         This must be at least  max |e(j)**2|*safe_min  and at",
       "         least safe_min, where safe_min is at least",
       "         the smallest number that can divide one without overflow."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N)",
       "         The offdiagonal elements of the tridiagonal matrix T in",
       "         positions 1 through N-1.  E(N) is arbitrary."],
     "E2"=>
      ["[in]",
       "         E2 is REAL array, dimension (N)",
       "         The squares of the offdiagonal elements of the tridiagonal",
       "         matrix T.  E2(N) is ignored."],
     "NVAL"=>
      ["[in,out]",
       "         NVAL is INTEGER array, dimension (MINP)",
       "         If IJOB=1 or 2, not referenced.",
       "         If IJOB=3, the desired values of N(w).  The elements of NVAL",
       "         will be reordered to correspond with the intervals in AB.",
       "         Thus, NVAL(j) on output will not, in general be the same as",
       "         NVAL(j) on input, but it will correspond with the interval",
       "         (AB(j,1),AB(j,2)] on output."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (MMAX,2)",
       "         The endpoints of the intervals.  AB(j,1) is  a(j), the left",
       "         endpoint of the j-th interval, and AB(j,2) is b(j), the",
       "         right endpoint of the j-th interval.  The input intervals",
       "         will, in general, be modified, split, and reordered by the",
       "         calculation."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (MMAX)",
       "         If IJOB=1, ignored.",
       "         If IJOB=2, workspace.",
       "         If IJOB=3, then on input C(j) should be initialized to the",
       "         first search point in the binary search."],
     "MOUT"=>
      ["[out]",
       "         MOUT is INTEGER",
       "         If IJOB=1, the number of eigenvalues in the intervals.",
       "         If IJOB=2 or 3, the number of intervals output.",
       "         If IJOB=3, MOUT will equal MINP."],
     "NAB"=>
      ["[in,out]",
       "         NAB is INTEGER array, dimension (MMAX,2)",
       "         If IJOB=1, then on output NAB(i,j) will be set to N(AB(i,j)).",
       "         If IJOB=2, then on input, NAB(i,j) should be set.  It must",
       "            satisfy the condition:",
       "            N(AB(i,1)) <= NAB(i,1) <= NAB(i,2) <= N(AB(i,2)),",
       "            which means that in interval i only eigenvalues",
       "            NAB(i,1)+1,...,NAB(i,2) will be considered.  Usually,",
       "            NAB(i,j)=N(AB(i,j)), from a previous call to SLAEBZ with",
       "            IJOB=1.",
       "            On output, NAB(i,j) will contain",
       "            max(na(k),min(nb(k),N(AB(i,j)))), where k is the index of",
       "            the input interval that the output interval",
       "            (AB(j,1),AB(j,2)] came from, and na(k) and nb(k) are the",
       "            the input values of NAB(k,1) and NAB(k,2).",
       "         If IJOB=3, then on output, NAB(i,j) contains N(AB(i,j)),",
       "            unless N(w) > NVAL(i) for all search points  w , in which",
       "            case NAB(i,1) will not be modified, i.e., the output",
       "            value will be the same as the input value (modulo",
       "            reorderings -- see NVAL and AB), or unless N(w) < NVAL(i)",
       "            for all search points  w , in which case NAB(i,2) will",
       "            not be modified.  Normally, NAB should be set to some",
       "            distinctive value(s) before SLAEBZ is called."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MMAX)",
       "         Workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MMAX)",
       "         Workspace."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:       All intervals converged.",
       "         = 1--MMAX: The last INFO intervals did not converge.",
       "         = MMAX+1:  More than MMAX intervals were generated."]}},
 "dlapll"=>
  {"summary"=>
    ["Given two column vectors X and Y, let",
     "                     A = ( X Y ).",
     "The subroutine first computes the QR factorization of A = Q*R,",
     "and then computes the SVD of the 2-by-2 upper triangular matrix R.",
     "The smaller singular value of R is returned in SSMIN, which is used",
     "as the measurement of the linear dependency of the vectors X and Y."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The length of the vectors X and Y."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array,",
       "                        dimension (1+(N-1)*INCX)",
       "         On entry, X contains the N-vector X.",
       "         On exit, X is overwritten."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array,",
       "                        dimension (1+(N-1)*INCY)",
       "         On entry, Y contains the N-vector Y.",
       "         On exit, Y is overwritten."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between successive elements of Y. INCY > 0."],
     "SSMIN"=>
      ["[out]",
       "         SSMIN is DOUBLE PRECISION",
       "         The smallest singular value of the N-by-2 matrix A = ( X Y )."]}},
 "checon_3"=>
  {"summary"=>
    ["CHECON_3 estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex Hermitian matrix A using the factorization",
     "computed by CHETRF_RK or CHETRF_BK:",
     "   A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).",
     "This routine uses BLAS3 solver CHETRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**H)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**H)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by CHETRF_RK and CHETRF_BK:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF_RK or CHETRF_BK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgehrd"=>
  {"summary"=>
    ["DGEHRD reduces a real general matrix A to upper Hessenberg form H by",
     "an orthogonal similarity transformation:  Q**T * A * Q = H ."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that A is already upper triangular in rows",
       "         and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "         set by a previous call to DGEBAL; otherwise they should be",
       "         set to 1 and N respectively. See Further Details.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         elements below the first subdiagonal, with the array TAU,",
       "         represent the orthogonal matrix Q as a product of elementary",
       "         reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details). Elements 1:ILO-1 and IHI:N-1 of TAU are set to",
       "         zero."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,N).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "stplqt2"=>
  {"summary"=>
    ["STPLQT2 computes a LQ a factorization of a real \"triangular-pentagonal\"",
     "matrix C, which is composed of a triangular block A and pentagonal block B,",
     "using the compact WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of",
       "         the triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the lower trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the lower triangular M-by-M matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the lower triangular matrix L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first N-L columns",
       "         are rectangular, and the last L columns are lower trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,M)",
       "         The N-by-N upper triangular factor T of the block reflector.",
       "         See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dsbevd"=>
  {"summary"=>
    ["DSBEVD computes all the eigenvalues and, optionally, eigenvectors of",
     "a real symmetric band matrix A. If eigenvectors are desired, it uses",
     "a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array,",
       "                                        dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         IF N <= 1,                LWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 2, LWORK must be at least 2*N.",
       "         If JOBZ  = 'V' and N > 2, LWORK must be at least",
       "                        ( 1 + 5*N + 2*N**2 ).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 2, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "zlantb"=>
  {"summary"=>
    ["ZLANTB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n triangular band matrix A,  with ( k + 1 ) diagonals.",
     "   ZLANTB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANTB as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANTB is",
       "         set to zero."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals of the matrix A if UPLO = 'L'.",
       "         K >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first k+1 rows of AB.  The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)   = A(i,j) for j<=i<=min(n,j+k).",
       "         Note that when DIAG = 'U', the elements of the array AB",
       "         corresponding to the diagonal elements of the matrix A are",
       "         not referenced, but are assumed to be one."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= K+1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "cpbrfs"=>
  {"summary"=>
    ["CPBRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian positive definite",
     "and banded, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The upper or lower triangle of the Hermitian band matrix A,",
       "         stored in the first KD+1 rows of the array.  The j-th column",
       "         of A is stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX array, dimension (LDAFB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H of the band matrix A as computed by",
       "         CPBTRF, in the same storage format as A (see AB)."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "         The leading dimension of the array AFB.  LDAFB >= KD+1."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by CPBTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chesv_aa"=>
  {"summary"=>
    ["CHESV_AA computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS",
     "matrices.",
     "Aasen's algorithm is used to factor A as",
     "   A = U * T * U**H,  if UPLO = 'U', or",
     "   A = L * T * L**H,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is Hermitian and tridiagonal. The factored form",
     "of A is then used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the tridiagonal matrix T and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*T*U**H or A = L*T*L**H as computed by",
       "         CHETRF_AA."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= MAX(1,2*N,3*N-2), and for best ",
       "         performance LWORK >= MAX(1,N*NB), where NB is the optimal",
       "         blocksize for CHETRF.",
       "         for LWORK < N, TRS will be done with Level BLAS 2",
       "         for LWORK >= N, TRS will be done with Level BLAS 3",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "sgtts2"=>
  {"summary"=>
    ["SGTTS2 solves one of the systems of equations",
     "   A*X = B  or  A**T*X = B,",
     "with a tridiagonal matrix A using the LU factorization computed",
     "by SGTTRF."],
   "param"=>
    {"ITRANS"=>
      ["[in]",
       "         ITRANS is INTEGER",
       "         Specifies the form of the system of equations.",
       "         = 0:  A * X = B  (No transpose)",
       "         = 1:  A**T* X = B  (Transpose)",
       "         = 2:  A**T* X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is REAL array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is REAL array, dimension (N-1)",
       "         The (n-1) elements of the first super-diagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is REAL array, dimension (N-2)",
       "         The (n-2) elements of the second super-diagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the matrix of right hand side vectors B.",
       "         On exit, B is overwritten by the solution vectors X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."]}},
 "zpbrfs"=>
  {"summary"=>
    ["ZPBRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian positive definite",
     "and banded, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The upper or lower triangle of the Hermitian band matrix A,",
       "         stored in the first KD+1 rows of the array.  The j-th column",
       "         of A is stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX*16 array, dimension (LDAFB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H of the band matrix A as computed by",
       "         ZPBTRF, in the same storage format as A (see AB)."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "         The leading dimension of the array AFB.  LDAFB >= KD+1."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by ZPBTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cpbtrs"=>
  {"summary"=>
    ["CPBTRS solves a system of linear equations A*X = B with a Hermitian",
     "positive definite band matrix A using the Cholesky factorization",
     "A = U**H*U or A = L*L**H computed by CPBTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor stored in AB;",
       "         = 'L':  Lower triangular factor stored in AB."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H of the band matrix A, stored in the",
       "         first KD+1 rows of the array.  The j-th column of U or L is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO ='U', AB(kd+1+i-j,j) = U(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO ='L', AB(1+i-j,j)    = L(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zggsvd3"=>
  {"summary"=>
    ["ZGGSVD3 computes the generalized singular value decomposition (GSVD)",
     "of an M-by-N complex matrix A and P-by-N complex matrix B:",
     "      U**H*A*Q = D1*( 0 R ),    V**H*B*Q = D2*( 0 R )",
     "where U, V and Q are unitary matrices.",
     "Let K+L = the effective numerical rank of the",
     "matrix (A**H,B**H)**H, then R is a (K+L)-by-(K+L) nonsingular upper",
     "triangular matrix, D1 and D2 are M-by-(K+L) and P-by-(K+L) \"diagonal\"",
     "matrices and of the following structures, respectively:",
     "If M-K-L >= 0,",
     "                    K  L",
     "       D1 =     K ( I  0 )",
     "                L ( 0  C )",
     "            M-K-L ( 0  0 )",
     "                  K  L",
     "       D2 =   L ( 0  S )",
     "            P-L ( 0  0 )",
     "                N-K-L  K    L",
     "  ( 0 R ) = K (  0   R11  R12 )",
     "            L (  0    0   R22 )",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(K+L) ),",
     "  S = diag( BETA(K+1),  ... , BETA(K+L) ),",
     "  C**2 + S**2 = I.",
     "  R is stored in A(1:K+L,N-K-L+1:N) on exit.",
     "If M-K-L < 0,",
     "                  K M-K K+L-M",
     "       D1 =   K ( I  0    0   )",
     "            M-K ( 0  C    0   )",
     "                    K M-K K+L-M",
     "       D2 =   M-K ( 0  S    0  )",
     "            K+L-M ( 0  0    I  )",
     "              P-L ( 0  0    0  )",
     "                   N-K-L  K   M-K  K+L-M",
     "  ( 0 R ) =     K ( 0    R11  R12  R13  )",
     "              M-K ( 0     0   R22  R23  )",
     "            K+L-M ( 0     0    0   R33  )",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(M) ),",
     "  S = diag( BETA(K+1),  ... , BETA(M) ),",
     "  C**2 + S**2 = I.",
     "  (R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N), and R33 is stored",
     "  ( 0  R22 R23 )",
     "  in B(M-K+1:L,N+M-K-L+1:N) on exit.",
     "The routine computes C, S, R, and optionally the unitary",
     "transformation matrices U, V and Q.",
     "In particular, if B is an N-by-N nonsingular matrix, then the GSVD of",
     "A and B implicitly gives the SVD of A*inv(B):",
     "                     A*inv(B) = U*(D1*inv(D2))*V**H.",
     "If ( A**H,B**H)**H has orthonormal columns, then the GSVD of A and B is also",
     "equal to the CS decomposition of A and B. Furthermore, the GSVD can",
     "be used to derive the solution of the eigenvalue problem:",
     "                     A**H*A x = lambda* B**H*B x.",
     "In some literature, the GSVD of A and B is presented in the form",
     "                 U**H*A*X = ( 0 D1 ),   V**H*B*X = ( 0 D2 )",
     "where U and V are orthogonal and X is nonsingular, and D1 and D2 are",
     "``diagonal''.  The former GSVD form can be converted to the latter",
     "form by taking the nonsingular matrix X as",
     "                      X = Q*(  I   0    )",
     "                            (  0 inv(R) )"],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  Unitary matrix U is computed;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  Unitary matrix V is computed;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Unitary matrix Q is computed;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "K"=>["[out]", "         K is INTEGER"],
     "L"=>
      ["[out]",
       "         L is INTEGER",
       "         On exit, K and L specify the dimension of the subblocks",
       "         described in Purpose.",
       "         K + L = effective numerical rank of (A**H,B**H)**H."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A contains the triangular matrix R, or part of R.",
       "         See Purpose for details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, B contains part of the triangular matrix R if",
       "         M-K-L < 0.  See Purpose for details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "ALPHA"=>
      ["[out]", "         ALPHA is DOUBLE PRECISION array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         On exit, ALPHA and BETA contain the generalized singular",
       "         value pairs of A and B;",
       "           ALPHA(1:K) = 1,",
       "           BETA(1:K)  = 0,",
       "         and if M-K-L >= 0,",
       "           ALPHA(K+1:K+L) = C,",
       "           BETA(K+1:K+L)  = S,",
       "         or if M-K-L < 0,",
       "           ALPHA(K+1:M)=C, ALPHA(M+1:K+L)=0",
       "           BETA(K+1:M) =S, BETA(M+1:K+L) =1",
       "         and",
       "           ALPHA(K+L+1:N) = 0",
       "           BETA(K+L+1:N)  = 0"],
     "U"=>
      ["[out]",
       "         U is COMPLEX*16 array, dimension (LDU,M)",
       "         If JOBU = 'U', U contains the M-by-M unitary matrix U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[out]",
       "         V is COMPLEX*16 array, dimension (LDV,P)",
       "         If JOBV = 'V', V contains the P-by-P unitary matrix V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,N)",
       "         If JOBQ = 'Q', Q contains the N-by-N unitary matrix Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N)",
       "         On exit, IWORK stores the sorting information. More",
       "         precisely, the following loop will sort ALPHA",
       "            for I = K+1, min(M,K+L)",
       "                swap ALPHA(I) and ALPHA(IWORK(I))",
       "            endfor",
       "         such that ALPHA(1) >= ALPHA(2) >= ... >= ALPHA(N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, the Jacobi-type procedure failed to",
       "               converge.  For further details, see subroutine ZTGSJA."]}},
 "cgeequb"=>
  {"summary"=>
    ["CGEEQUB computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most",
     "the radix.",
     "R(i) and C(j) are restricted to be a power of the radix between",
     "SMLNUM = smallest safe number and BIGNUM = largest safe number.  Use",
     "of these scaling factors is not guaranteed to reduce the condition",
     "number of A but works well in practice.",
     "This routine differs from CGEEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled entries' magnitudes are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The M-by-N matrix whose equilibration factors are",
       "         to be computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is REAL array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is REAL array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is REAL",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is REAL",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "dormtr"=>
  {"summary"=>
    ["DORMTR overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "nq-1 elementary reflectors, as returned by DSYTRD:",
     "if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangle of A contains elementary reflectors",
       "                from DSYTRD;",
       "         = 'L': Lower triangle of A contains elementary reflectors",
       "                from DSYTRD."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension",
       "                              (LDA,M) if SIDE = 'L'",
       "                              (LDA,N) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by DSYTRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension",
       "                              (M-1) if SIDE = 'L'",
       "                              (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DSYTRD."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For optimum performance LWORK >= N*NB if SIDE = 'L', and",
       "         LWORK >= M*NB if SIDE = 'R', where NB is the optimal",
       "         blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlagtm"=>
  {"summary"=>
    ["DLAGTM performs a matrix-vector product of the form",
     "   B := alpha * A * X + beta * B",
     "where A is a tridiagonal matrix of order N, B and X are N by NRHS",
     "matrices, and alpha and beta are real scalars, each of which may be",
     "0., 1., or -1."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  No transpose, B := alpha * A * X + beta * B",
       "         = 'T':  Transpose,    B := alpha * A'* X + beta * B",
       "         = 'C':  Conjugate transpose = Transpose"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices X and B."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "         The scalar alpha.  ALPHA must be 0., 1., or -1.; otherwise,",
       "         it is assumed to be 0."],
     "DL"=>
      ["[in]",
       "         DL is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) sub-diagonal elements of T."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of T."],
     "DU"=>
      ["[in]",
       "         DU is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) super-diagonal elements of T."],
     "X"=>
      ["[in]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         The N by NRHS matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(N,1)."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION",
       "         The scalar beta.  BETA must be 0., 1., or -1.; otherwise,",
       "         it is assumed to be 1."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N by NRHS matrix B.",
       "         On exit, B is overwritten by the matrix expression",
       "         B := alpha * A * X + beta * B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(N,1)."]}},
 "cgerq2"=>
  {"summary"=>
    ["CGERQ2 computes an RQ factorization of a complex m by n matrix A:",
     "A = R * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, if m <= n, the upper triangle of the subarray",
       "         A(1:m,n-m+1:n) contains the m by m upper triangular matrix R;",
       "         if m >= n, the elements on and above the (m-n)-th subdiagonal",
       "         contain the m by n upper trapezoidal matrix R; the remaining",
       "         elements, with the array TAU, represent the unitary matrix",
       "         Q as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dsbgvx"=>
  {"summary"=>
    ["DSBGVX computes selected eigenvalues, and optionally, eigenvectors",
     "of a real generalized symmetric-definite banded eigenproblem, of",
     "the form A*x=(lambda)*B*x.  Here A and B are assumed to be symmetric",
     "and banded, and B is also positive definite.  Eigenvalues and",
     "eigenvectors can be selected by specifying either all eigenvalues,",
     "a range of values or a range of indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is DOUBLE PRECISION array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(ka+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**T*S, as returned by DPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "Q"=>
      ["[out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the n-by-n matrix used in the reduction of",
       "         A*x = (lambda)*B*x to standard form, i.e. C*x = (lambda)*x,",
       "         and consequently C to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'N',",
       "         LDQ >= 1. If JOBZ = 'V', LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i).  The eigenvectors are",
       "         normalized so Z**T*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (M)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvalues that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit",
       "         < 0 : if INFO = -i, the i-th argument had an illegal value",
       "         <= N: if INFO = i, then i eigenvectors failed to converge.",
       "                 Their indices are stored in IFAIL.",
       "         > N : DPBSTF returned an error code; i.e.,",
       "               if INFO = N + i, for 1 <= i <= N, then the leading",
       "               minor of order i of B is not positive definite.",
       "               The factorization of B could not be completed and",
       "               no eigenvalues or eigenvectors were computed."]}},
 "dpbtrf"=>
  {"summary"=>
    ["DPBTRF computes the Cholesky factorization of a real symmetric",
     "positive definite band matrix A.",
     "The factorization has the form",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**T*U or A = L*L**T of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "dsytrf_aa"=>
  {"summary"=>
    ["DSYTRF_AA computes the factorization of a real symmetric matrix A",
     "using the Aasen's algorithm.  The form of the factorization is",
     "   A = U*T*U**T  or  A = L*T*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is a symmetric tridiagonal matrix.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the tridiagonal matrix is stored in the diagonals",
       "         and the subdiagonals of A just below (or above) the diagonals,",
       "         and L is stored below (or above) the subdiaonals, when UPLO",
       "         is 'L' (or 'U')."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= MAX(1,2*N). For optimum performance",
       "         LWORK >= N*(1+NB), where NB is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "chesv_rook"=>
  {"summary"=>
    ["CHESV_ROOK computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS",
     "matrices.",
     "The bounded Bunch-Kaufman (\"rook\") diagonal pivoting method is used",
     "to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is Hermitian and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "CHETRF_ROOK is called to compute the factorization of a complex",
     "Hermition matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal",
     "pivoting method.",
     "The factored form of A is then used to solve the system",
     "of equations A * X = B by calling CHETRS_ROOK (uses BLAS 2)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**H or A = L*D*L**H as computed by",
       "         CHETRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         CHETRF_ROOK.",
       "         for LWORK < N, TRS will be done with Level BLAS 2",
       "         for LWORK >= N, TRS will be done with Level BLAS 3",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed.",
       " November 2013,  Igor Kozachenko,",
       "                 Computer Science Division,",
       "                 University of California, Berkeley",
       " September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas,",
       "                 School of Mathematics,",
       "                 University of Manchester"]}},
 "ctgsyl"=>
  {"summary"=>
    ["CTGSYL solves the generalized Sylvester equation:",
     "            A * R - L * B = scale * C            (1)",
     "            D * R - L * E = scale * F",
     "where R and L are unknown m-by-n matrices, (A, D), (B, E) and",
     "(C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n,",
     "respectively, with complex entries. A, B, D and E are upper",
     "triangular (i.e., (A,D) and (B,E) in generalized Schur form).",
     "The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1",
     "is an output scaling factor chosen to avoid overflow.",
     "In matrix notation (1) is equivalent to solve Zx = scale*b, where Z",
     "is defined as",
     "       Z = [ kron(In, A)  -kron(B**H, Im) ]        (2)",
     "           [ kron(In, D)  -kron(E**H, Im) ],",
     "Here Ix is the identity matrix of size x and X**H is the conjugate",
     "transpose of X. Kron(X, Y) is the Kronecker product between the",
     "matrices X and Y.",
     "If TRANS = 'C', y in the conjugate transposed system Z**H *y = scale*b",
     "is solved for, which is equivalent to solve for R and L in",
     "            A**H * R + D**H * L = scale * C           (3)",
     "            R * B**H + L * E**H = scale * -F",
     "This case (TRANS = 'C') is used to compute an one-norm-based estimate",
     "of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D)",
     "and (B,E), using CLACON.",
     "If IJOB >= 1, CTGSYL computes a Frobenius norm-based estimate of",
     "Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the",
     "reciprocal of the smallest singular value of Z.",
     "This is a level-3 BLAS algorithm."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': solve the generalized sylvester equation (1).",
       "         = 'C': solve the \"conjugate transposed\" system (3)."],
     "IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies what kind of functionality to be performed.",
       "         =0: solve (1) only.",
       "         =1: The functionality of 0 and 3.",
       "         =2: The functionality of 0 and 4.",
       "         =3: Only an estimate of Dif[(A,D), (B,E)] is computed.",
       "             (look ahead strategy is used).",
       "         =4: Only an estimate of Dif[(A,D), (B,E)] is computed.",
       "             (CGECON on sub-systems is used).",
       "         Not referenced if TRANS = 'C'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The order of the matrices A and D, and the row dimension of",
       "         the matrices C, F, R and L."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices B and E, and the column dimension",
       "         of the matrices C, F, R and L."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA, M)",
       "         The upper triangular matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1, M)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         The upper triangular matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1, N)."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC, N)",
       "         On entry, C contains the right-hand-side of the first matrix",
       "         equation in (1) or (3).",
       "         On exit, if IJOB = 0, 1 or 2, C has been overwritten by",
       "         the solution R. If IJOB = 3 or 4 and TRANS = 'N', C holds R,",
       "         the solution achieved during the computation of the",
       "         Dif-estimate."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1, M)."],
     "D"=>
      ["[in]",
       "         D is COMPLEX array, dimension (LDD, M)",
       "         The upper triangular matrix D."],
     "LDD"=>
      ["[in]",
       "         LDD is INTEGER",
       "         The leading dimension of the array D. LDD >= max(1, M)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (LDE, N)",
       "         The upper triangular matrix E."],
     "LDE"=>
      ["[in]",
       "         LDE is INTEGER",
       "         The leading dimension of the array E. LDE >= max(1, N)."],
     "F"=>
      ["[in,out]",
       "         F is COMPLEX array, dimension (LDF, N)",
       "         On entry, F contains the right-hand-side of the second matrix",
       "         equation in (1) or (3).",
       "         On exit, if IJOB = 0, 1 or 2, F has been overwritten by",
       "         the solution L. If IJOB = 3 or 4 and TRANS = 'N', F holds L,",
       "         the solution achieved during the computation of the",
       "         Dif-estimate."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the array F. LDF >= max(1, M)."],
     "DIF"=>
      ["[out]",
       "         DIF is REAL",
       "         On exit DIF is the reciprocal of a lower bound of the",
       "         reciprocal of the Dif-function, i.e. DIF is an upper bound of",
       "         Dif[(A,D), (B,E)] = sigma-min(Z), where Z as in (2).",
       "         IF IJOB = 0 or TRANS = 'C', DIF is not referenced."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         On exit SCALE is the scaling factor in (1) or (3).",
       "         If 0 < SCALE < 1, C and F hold the solutions R and L, resp.,",
       "         to a slightly perturbed system but the input matrices A, B,",
       "         D and E have not been changed. If SCALE = 0, R and L will",
       "         hold the solutions to the homogenious system with C = F = 0."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK > = 1.",
       "         If IJOB = 1 or 2 and TRANS = 'N', LWORK >= max(1,2*M*N).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (M+N+2)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "           =0: successful exit",
       "           <0: If INFO = -i, the i-th argument had an illegal value.",
       "           >0: (A, D) and (B, E) have common or very close",
       "               eigenvalues."]}},
 "ztgex2"=>
  {"summary"=>
    ["ZTGEX2 swaps adjacent diagonal 1 by 1 blocks (A11,B11) and (A22,B22)",
     "in an upper triangular matrix pair (A, B) by an unitary equivalence",
     "transformation.",
     "(A, B) must be in generalized Schur canonical form, that is, A and",
     "B are both upper triangular.",
     "Optionally, the matrices Q and Z of generalized Schur vectors are",
     "updated.",
     "       Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H",
     "       Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H"],
   "param"=>
    {"WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 arrays, dimensions (LDA,N)",
       "         On entry, the matrix A in the pair (A, B).",
       "         On exit, the updated matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 arrays, dimensions (LDB,N)",
       "         On entry, the matrix B in the pair (A, B).",
       "         On exit, the updated matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDZ,N)",
       "         If WANTQ = .TRUE, on entry, the unitary matrix Q. On exit,",
       "         the updated matrix Q.",
       "         Not referenced if WANTQ = .FALSE.."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= 1;",
       "         If WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ,N)",
       "         If WANTZ = .TRUE, on entry, the unitary matrix Z. On exit,",
       "         the updated matrix Z.",
       "         Not referenced if WANTZ = .FALSE.."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1;",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The index to the first block (A11, B11)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          =0:  Successful exit.",
       "          =1:  The transformed matrix pair (A, B) would be too far",
       "               from generalized Schur form; the problem is ill-",
       "               conditioned."]}},
 "clangb"=>
  {"summary"=>
    ["CLANGB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n band matrix  A,  with kl sub-diagonals and ku super-diagonals.",
     "   CLANGB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANGB as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANGB is",
       "         set to zero."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of sub-diagonals of the matrix A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of super-diagonals of the matrix A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The band matrix A, stored in rows 1 to KL+KU+1.  The j-th",
       "         column of A is stored in the j-th column of the array AB as",
       "         follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "ctgsna"=>
  {"summary"=>
    ["CTGSNA estimates reciprocal condition numbers for specified",
     "eigenvalues and/or eigenvectors of a matrix pair (A, B).",
     "(A, B) must be in generalized Schur canonical form, that is, A and",
     "B are both upper triangular."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for",
       "         eigenvalues (S) or eigenvectors (DIF):",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for eigenvectors only (DIF);",
       "         = 'B': for both eigenvalues and eigenvectors (S and DIF)."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute condition numbers for all eigenpairs;",
       "         = 'S': compute condition numbers for selected eigenpairs",
       "                specified by the array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenpairs for which",
       "         condition numbers are required. To select condition numbers",
       "         for the corresponding j-th eigenvalue and/or eigenvector,",
       "         SELECT(j) must be set to .TRUE..",
       "         If HOWMNY = 'A', SELECT is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the square matrix pair (A, B). N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The upper triangular matrix A in the pair (A,B)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         The upper triangular matrix B in the pair (A, B)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is COMPLEX array, dimension (LDVL,M)",
       "         IF JOB = 'E' or 'B', VL must contain left eigenvectors of",
       "         (A, B), corresponding to the eigenpairs specified by HOWMNY",
       "         and SELECT.  The eigenvectors must be stored in consecutive",
       "         columns of VL, as returned by CTGEVC.",
       "         If JOB = 'V', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL. LDVL >= 1; and",
       "         If JOB = 'E' or 'B', LDVL >= N."],
     "VR"=>
      ["[in]",
       "         VR is COMPLEX array, dimension (LDVR,M)",
       "         IF JOB = 'E' or 'B', VR must contain right eigenvectors of",
       "         (A, B), corresponding to the eigenpairs specified by HOWMNY",
       "         and SELECT.  The eigenvectors must be stored in consecutive",
       "         columns of VR, as returned by CTGEVC.",
       "         If JOB = 'V', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR. LDVR >= 1;",
       "         If JOB = 'E' or 'B', LDVR >= N."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (MM)",
       "         If JOB = 'E' or 'B', the reciprocal condition numbers of the",
       "         selected eigenvalues, stored in consecutive elements of the",
       "         array.",
       "         If JOB = 'V', S is not referenced."],
     "DIF"=>
      ["[out]",
       "         DIF is REAL array, dimension (MM)",
       "         If JOB = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the selected eigenvectors, stored in consecutive",
       "         elements of the array.",
       "         If the eigenvalues cannot be reordered to compute DIF(j),",
       "         DIF(j) is set to 0; this can only occur when the true value",
       "         would be very small anyway.",
       "         For each eigenvalue/vector specified by SELECT, DIF stores",
       "         a Frobenius norm-based estimate of Difl.",
       "         If JOB = 'E', DIF is not referenced."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of elements in the arrays S and DIF. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of elements of the arrays S and DIF used to store",
       "         the specified condition numbers; for each selected eigenvalue",
       "         one element is used. If HOWMNY = 'A', M is set to N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         If JOB = 'V' or 'B', LWORK >= max(1,2*N*N)."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N+2)",
       "         If JOB = 'E', IWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: Successful exit",
       "         < 0: If INFO = -i, the i-th argument had an illegal value"]}},
 "zla_hercond_c"=>
  {"summary"=>
    ["   ZLA_HERCOND_C computes the infinity norm condition number of",
     "   op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by ZHETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by CHETRF."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The vector C in the formula op(A) * inv(diag(C))."],
     "CAPPLY"=>
      ["[in]",
       "         CAPPLY is LOGICAL",
       "    If .TRUE. then access the vector C in the formula above."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX*16 array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is DOUBLE PRECISION array, dimension (N).",
       "    Workspace."]}},
 "zlaqge"=>
  {"summary"=>
    ["ZLAQGE equilibrates a general M by N matrix A using the row and",
     "column scaling factors in the vectors R and C."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M by N matrix A.",
       "         On exit, the equilibrated matrix.  See EQUED for the form of",
       "         the equilibrated matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "R"=>
      ["[in]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         The row scale factors for A."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         The column scale factors for A."],
     "ROWCND"=>
      ["[in]",
       "         ROWCND is DOUBLE PRECISION",
       "         Ratio of the smallest R(i) to the largest R(i)."],
     "COLCND"=>
      ["[in]",
       "         COLCND is DOUBLE PRECISION",
       "         Ratio of the smallest C(i) to the largest C(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies the form of equilibration that was done.",
       "         = 'N':  No equilibration",
       "         = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "                 diag(R).",
       "         = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "                 by diag(C).",
       "         = 'B':  Both row and column equilibration, i.e., A has been",
       "                 replaced by diag(R) * A * diag(C)."]}},
 "slarzt"=>
  {"summary"=>
    ["SLARZT forms the triangular factor T of a real block reflector",
     "H of order > n, which is defined as a product of k elementary",
     "reflectors.",
     "If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;",
     "If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.",
     "If STOREV = 'C', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th column of the array V, and",
     "   H  =  I - V * T * V**T",
     "If STOREV = 'R', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th row of the array V, and",
     "   H  =  I - V**T * T * V",
     "Currently, only STOREV = 'R' and DIRECT = 'B' are supported."],
   "param"=>
    {"DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies the order in which the elementary reflectors are",
       "         multiplied to form the block reflector:",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Specifies how the vectors which define the elementary",
       "         reflectors are stored (see also Further Details):",
       "         = 'C': columnwise                        (not supported yet)",
       "         = 'R': rowwise"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the block reflector H. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the triangular factor T (= the number of",
       "         elementary reflectors). K >= 1."],
     "V"=>
      ["[in,out]",
       "         V is REAL array, dimension",
       "                              (LDV,K) if STOREV = 'C'",
       "                              (LDV,N) if STOREV = 'R'",
       "         The matrix V. See further details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,K)",
       "         The k by k triangular factor T of the block reflector.",
       "         If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is",
       "         lower triangular. The rest of the array is not used."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."]}},
 "dlarft"=>
  {"summary"=>
    ["DLARFT forms the triangular factor T of a real block reflector H",
     "of order n, which is defined as a product of k elementary reflectors.",
     "If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;",
     "If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.",
     "If STOREV = 'C', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th column of the array V, and",
     "   H  =  I - V * T * V**T",
     "If STOREV = 'R', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th row of the array V, and",
     "   H  =  I - V**T * T * V"],
   "param"=>
    {"DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies the order in which the elementary reflectors are",
       "         multiplied to form the block reflector:",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Specifies how the vectors which define the elementary",
       "         reflectors are stored (see also Further Details):",
       "         = 'C': columnwise",
       "         = 'R': rowwise"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the block reflector H. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the triangular factor T (= the number of",
       "         elementary reflectors). K >= 1."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension",
       "                              (LDV,K) if STOREV = 'C'",
       "                              (LDV,N) if STOREV = 'R'",
       "         The matrix V. See further details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,K)",
       "         The k by k triangular factor T of the block reflector.",
       "         If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is",
       "         lower triangular. The rest of the array is not used."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."]}},
 "sgelq"=>
  {"summary"=>["SGELQ computes a LQ factorization of an M-by-N matrix A."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the M-by-min(M,N) lower trapezoidal matrix L",
       "         (L is lower triangular if M <= N);",
       "         the elements above the diagonal are used to store part of the ",
       "         data structure to represent Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (MAX(5,TSIZE))",
       "         On exit, if INFO = 0, T(1) returns optimal (or either minimal ",
       "         or optimal, if query is assumed) TSIZE. See TSIZE for details.",
       "         Remaining T contains part of the data structure used to represent Q.",
       "         If one wants to apply or construct Q, then one needs to keep T ",
       "         (in addition to A) and pass it to further subroutines."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         If TSIZE >= 5, the dimension of the array T.",
       "         If TSIZE = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If TSIZE = -1, the routine calculates optimal size of T for the ",
       "         optimum performance and returns this value in T(1).",
       "         If TSIZE = -2, the routine calculates minimal size of T and ",
       "         returns this value in T(1)."],
     "WORK"=>
      ["[out]",
       "         (workspace) REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhegst"=>
  {"summary"=>
    ["ZHEGST reduces a complex Hermitian-definite generalized",
     "eigenproblem to standard form.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L.",
     "B must have been previously factorized as U**H*U or L*L**H by ZPOTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H);",
       "         = 2 or 3: compute U*A*U**H or L**H*A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored and B is factored as",
       "                 U**H*U;",
       "         = 'L':  Lower triangle of A is stored and B is factored as",
       "                 L*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         as returned by ZPOTRF."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sla_gbrpvgrw"=>
  {"summary"=>
    ["SLA_GBRPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A.  NCOLS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "    On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is REAL array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by SGBTRF.  U is stored as an upper triangular",
       "    band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1,",
       "    and the multipliers used during the factorization are stored",
       "    in rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1."]}},
 "chetri_rook"=>
  {"summary"=>
    ["CHETRI_ROOK computes the inverse of a complex Hermitian indefinite matrix",
     "A using the factorization A = U*D*U**H or A = L*D*L**H computed by",
     "CHETRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CHETRF_ROOK.",
       "         On exit, if INFO = 0, the (Hermitian) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF_ROOK."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "ztrttp"=>
  {"summary"=>
    ["ZTRTTP copies a triangular matrix A from full format (TR) to standard",
     "packed format (TP)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices AP and A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AP"=>
      ["[out]",
       "         AP is COMPLEX*16 array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgesvx"=>
  {"summary"=>
    ["SGESVX uses the LU factorization to compute the solution to a real",
     "system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N matrix and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "dtbtrs"=>
  {"summary"=>
    ["DTBTRS solves a triangular system of the form",
     "   A * X = B  or  A**T * X = B,",
     "where A is a triangular band matrix of order N, and B is an",
     "N-by NRHS matrix.  A check is made to verify that A is nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of AB.  The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element of A is zero,",
       "               indicating that the matrix is singular and the",
       "               solutions X have not been computed."]}},
 "zlaic1"=>
  {"summary"=>
    ["ZLAIC1 applies one step of incremental condition estimation in",
     "its simplest version:",
     "Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j",
     "lower triangular matrix L, such that",
     "         twonorm(L*x) = sest",
     "Then ZLAIC1 computes sestpr, s, c such that",
     "the vector",
     "                [ s*x ]",
     "         xhat = [  c  ]",
     "is an approximate singular vector of",
     "                [ L       0  ]",
     "         Lhat = [ w**H gamma ]",
     "in the sense that",
     "         twonorm(Lhat*xhat) = sestpr.",
     "Depending on JOB, an estimate for the largest or smallest singular",
     "value is computed.",
     "Note that [s c]**H and sestpr**2 is an eigenpair of the system",
     "    diag(sest*sest, 0) + [alpha  gamma] * [ conjg(alpha) ]",
     "                                          [ conjg(gamma) ]",
     "where  alpha =  x**H * w."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is INTEGER",
       "         = 1: an estimate for the largest singular value is computed.",
       "         = 2: an estimate for the smallest singular value is computed."],
     "J"=>["[in]", "         J is INTEGER", "         Length of X and W"],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension (J)",
       "         The j-vector x."],
     "SEST"=>
      ["[in]",
       "         SEST is DOUBLE PRECISION",
       "         Estimated singular value of j by j matrix L"],
     "W"=>
      ["[in]",
       "         W is COMPLEX*16 array, dimension (J)",
       "         The j-vector w."],
     "GAMMA"=>
      ["[in]",
       "         GAMMA is COMPLEX*16",
       "         The diagonal element gamma."],
     "SESTPR"=>
      ["[out]",
       "         SESTPR is DOUBLE PRECISION",
       "         Estimated singular value of (j+1) by (j+1) matrix Lhat."],
     "S"=>
      ["[out]",
       "         S is COMPLEX*16",
       "         Sine needed in forming xhat."],
     "C"=>
      ["[out]",
       "         C is COMPLEX*16",
       "         Cosine needed in forming xhat."]}},
 "strttf"=>
  {"summary"=>
    ["STRTTF copies a triangular matrix A from standard full format (TR)",
     "to rectangular full packed format (TF) ."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF in Normal form is wanted;",
       "         = 'T':  ARF in Transpose form is wanted."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N).",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the matrix A. LDA >= max(1,N)."],
     "ARF"=>
      ["[out]",
       "         ARF is REAL array, dimension (NT).",
       "         NT=N*(N+1)/2. On exit, the triangular matrix A in RFP format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zupmtr"=>
  {"summary"=>
    ["ZUPMTR overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "nq-1 elementary reflectors, as returned by ZHPTRD using packed",
     "storage:",
     "if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangular packed storage used in previous",
       "                call to ZHPTRD;",
       "         = 'L': Lower triangular packed storage used in previous",
       "                call to ZHPTRD."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension",
       "                              (M*(M+1)/2) if SIDE = 'L'",
       "                              (N*(N+1)/2) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by ZHPTRD.  AP is modified by the routine but",
       "         restored on exit."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (M-1) if SIDE = 'L'",
       "                                    or (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZHPTRD."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension",
       "                                  (N) if SIDE = 'L'",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhpev"=>
  {"summary"=>
    ["ZHPEV computes all the eigenvalues and, optionally, eigenvectors of a",
     "complex Hermitian matrix in packed storage."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (max(1, 2*N-1))"],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dlarrf"=>
  {"summary"=>
    ["Given the initial representation L D L^T and its cluster of close",
     "eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ...",
     "W( CLEND ), DLARRF finds a new relatively robust representation",
     "L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the",
     "eigenvalues of L(+) D(+) L(+)^T is relatively isolated."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix (subblock, if the matrix split)."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The N diagonal elements of the diagonal matrix D."],
     "L"=>
      ["[in]",
       "         L is DOUBLE PRECISION array, dimension (N-1)",
       "         The (N-1) subdiagonal elements of the unit bidiagonal",
       "         matrix L."],
     "LD"=>
      ["[in]",
       "         LD is DOUBLE PRECISION array, dimension (N-1)",
       "         The (N-1) elements L(i)*D(i)."],
     "CLSTRT"=>
      ["[in]",
       "         CLSTRT is INTEGER",
       "         The index of the first eigenvalue in the cluster."],
     "CLEND"=>
      ["[in]",
       "         CLEND is INTEGER",
       "         The index of the last eigenvalue in the cluster."],
     "W"=>
      ["[in]",
       "         W is DOUBLE PRECISION array, dimension",
       "         dimension is >=  (CLEND-CLSTRT+1)",
       "         The eigenvalue APPROXIMATIONS of L D L^T in ascending order.",
       "         W( CLSTRT ) through W( CLEND ) form the cluster of relatively",
       "         close eigenalues."],
     "WGAP"=>
      ["[in,out]",
       "         WGAP is DOUBLE PRECISION array, dimension",
       "         dimension is >=  (CLEND-CLSTRT+1)",
       "         The separation from the right neighbor eigenvalue in W."],
     "WERR"=>
      ["[in]",
       "         WERR is DOUBLE PRECISION array, dimension",
       "         dimension is  >=  (CLEND-CLSTRT+1)",
       "         WERR contain the semiwidth of the uncertainty",
       "         interval of the corresponding eigenvalue APPROXIMATION in W"],
     "SPDIAM"=>
      ["[in]",
       "         SPDIAM is DOUBLE PRECISION",
       "         estimate of the spectral diameter obtained from the",
       "         Gerschgorin intervals"],
     "CLGAPL"=>["[in]", "         CLGAPL is DOUBLE PRECISION"],
     "CLGAPR"=>
      ["[in]",
       "         CLGAPR is DOUBLE PRECISION",
       "         absolute gap on each end of the cluster.",
       "         Set by the calling routine to protect against shifts too close",
       "         to eigenvalues outside the cluster."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "         The minimum pivot allowed in the Sturm sequence."],
     "SIGMA"=>
      ["[out]",
       "         SIGMA is DOUBLE PRECISION",
       "         The shift used to form L(+) D(+) L(+)^T."],
     "DPLUS"=>
      ["[out]",
       "         DPLUS is DOUBLE PRECISION array, dimension (N)",
       "         The N diagonal elements of the diagonal matrix D(+)."],
     "LPLUS"=>
      ["[out]",
       "         LPLUS is DOUBLE PRECISION array, dimension (N-1)",
       "         The first (N-1) elements of LPLUS contain the subdiagonal",
       "         elements of the unit bidiagonal matrix L(+)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (2*N)",
       "         Workspace."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         Signals processing OK (=0) or failure (=1)"]}},
 "ctgsen"=>
  {"summary"=>
    ["CTGSEN reorders the generalized Schur decomposition of a complex",
     "matrix pair (A, B) (in terms of an unitary equivalence trans-",
     "formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues",
     "appears in the leading diagonal blocks of the pair (A,B). The leading",
     "columns of Q and Z form unitary bases of the corresponding left and",
     "right eigenspaces (deflating subspaces). (A, B) must be in",
     "generalized Schur canonical form, that is, A and B are both upper",
     "triangular.",
     "CTGSEN also computes the generalized eigenvalues",
     "         w(j)= ALPHA(j) / BETA(j)",
     "of the reordered matrix pair (A, B).",
     "Optionally, the routine computes estimates of reciprocal condition",
     "numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11),",
     "(A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s)",
     "between the matrix pairs (A11, B11) and (A22,B22) that correspond to",
     "the selected cluster and the eigenvalues outside the cluster, resp.,",
     "and norms of \"projections\" onto left and right eigenspaces w.r.t.",
     "the selected cluster in the (1,1)-block."],
   "param"=>
    {"IJOB"=>
      ["[in]",
       "         IJOB is integer",
       "         Specifies whether condition numbers are required for the",
       "         cluster of eigenvalues (PL and PR) or the deflating subspaces",
       "         (Difu and Difl):",
       "          =0: Only reorder w.r.t. SELECT. No extras.",
       "          =1: Reciprocal of norms of \"projections\" onto left and right",
       "              eigenspaces w.r.t. the selected cluster (PL and PR).",
       "          =2: Upper bounds on Difu and Difl. F-norm-based estimate",
       "              (DIF(1:2)).",
       "          =3: Estimate of Difu and Difl. 1-norm-based estimate",
       "              (DIF(1:2)).",
       "              About 5 times as expensive as IJOB = 2.",
       "          =4: Compute PL, PR and DIF (i.e. 0, 1 and 2 above): Economic",
       "              version to get it all.",
       "          =5: Compute PL, PR and DIF (i.e. 0, 1 and 3 above)"],
     "WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         SELECT specifies the eigenvalues in the selected cluster. To",
       "         select an eigenvalue w(j), SELECT(j) must be set to",
       "         .TRUE.."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension(LDA,N)",
       "         On entry, the upper triangular matrix A, in generalized",
       "         Schur canonical form.",
       "         On exit, A is overwritten by the reordered matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension(LDB,N)",
       "         On entry, the upper triangular matrix B, in generalized",
       "         Schur canonical form.",
       "         On exit, B is overwritten by the reordered matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX array, dimension (N)",
       "         The diagonal elements of A and B, respectively,",
       "         when the pair (A,B) has been reduced to generalized Schur",
       "         form.  ALPHA(i)/BETA(i) i=1,...,N are the generalized",
       "         eigenvalues."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDQ,N)",
       "         On entry, if WANTQ = .TRUE., Q is an N-by-N matrix.",
       "         On exit, Q has been postmultiplied by the left unitary",
       "         transformation matrix which reorder (A, B); The leading M",
       "         columns of Q form orthonormal bases for the specified pair of",
       "         left eigenspaces (deflating subspaces).",
       "         If WANTQ = .FALSE., Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= 1.",
       "         If WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ,N)",
       "         On entry, if WANTZ = .TRUE., Z is an N-by-N matrix.",
       "         On exit, Z has been postmultiplied by the left unitary",
       "         transformation matrix which reorder (A, B); The leading M",
       "         columns of Z form orthonormal bases for the specified pair of",
       "         left eigenspaces (deflating subspaces).",
       "         If WANTZ = .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1.",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The dimension of the specified pair of left and right",
       "         eigenspaces, (deflating subspaces) 0 <= M <= N."],
     "PL"=>["[out]", "         PL is REAL"],
     "PR"=>
      ["[out]",
       "         PR is REAL",
       "         If IJOB = 1, 4 or 5, PL, PR are lower bounds on the",
       "         reciprocal  of the norm of \"projections\" onto left and right",
       "         eigenspace with respect to the selected cluster.",
       "         0 < PL, PR <= 1.",
       "         If M = 0 or M = N, PL = PR  = 1.",
       "         If IJOB = 0, 2 or 3 PL, PR are not referenced."],
     "DIF"=>
      ["[out]",
       "         DIF is REAL array, dimension (2).",
       "         If IJOB >= 2, DIF(1:2) store the estimates of Difu and Difl.",
       "         If IJOB = 2 or 4, DIF(1:2) are F-norm-based upper bounds on",
       "         Difu and Difl. If IJOB = 3 or 5, DIF(1:2) are 1-norm-based",
       "         estimates of Difu and Difl, computed using reversed",
       "         communication with CLACN2.",
       "         If M = 0 or N, DIF(1:2) = F-norm([A, B]).",
       "         If IJOB = 0 or 1, DIF is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >=  1",
       "         If IJOB = 1, 2 or 4, LWORK >=  2*M*(N-M)",
       "         If IJOB = 3 or 5, LWORK >=  4*M*(N-M)",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK. LIWORK >= 1.",
       "         If IJOB = 1, 2 or 4, LIWORK >=  N+2;",
       "         If IJOB = 3 or 5, LIWORK >= MAX(N+2, 2*M*(N-M));",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "           =0: Successful exit.",
       "           <0: If INFO = -i, the i-th argument had an illegal value.",
       "           =1: Reordering of (A, B) failed because the transformed",
       "               matrix pair (A, B) would be too far from generalized",
       "               Schur form; the problem is very ill-conditioned.",
       "               (A, B) may have been partially reordered.",
       "               If requested, 0 is returned in DIF(*), PL and PR."]}},
 "zgerq2"=>
  {"summary"=>
    ["ZGERQ2 computes an RQ factorization of a complex m by n matrix A:",
     "A = R * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, if m <= n, the upper triangle of the subarray",
       "         A(1:m,n-m+1:n) contains the m by m upper triangular matrix R;",
       "         if m >= n, the elements on and above the (m-n)-th subdiagonal",
       "         contain the m by n upper trapezoidal matrix R; the remaining",
       "         elements, with the array TAU, represent the unitary matrix",
       "         Q as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "ssfrk"=>
  {"summary"=>
    ["Level 3 BLAS like routine for C in RFP Format.",
     "SSFRK performs one of the symmetric rank--k operations",
     "   C := alpha*A*A**T + beta*C,",
     "or",
     "   C := alpha*A**T*A + beta*C,",
     "where alpha and beta are real scalars, C is an n--by--n symmetric",
     "matrix and A is an n--by--k matrix in the first case and a k--by--n",
     "matrix in the second case."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal Form of RFP A is stored;",
       "         = 'T':  The Transpose Form of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On  entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array C is to be referenced as",
       "          follows:",
       "             UPLO = 'U' or 'u'   Only the upper triangular part of C",
       "                                 is to be referenced.",
       "             UPLO = 'L' or 'l'   Only the lower triangular part of C",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "          On entry, TRANS specifies the operation to be performed as",
       "          follows:",
       "             TRANS = 'N' or 'n'   C := alpha*A*A**T + beta*C.",
       "             TRANS = 'T' or 't'   C := alpha*A**T*A + beta*C.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the order of the matrix C. N must be",
       "          at least zero.",
       "          Unchanged on exit."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "          On entry with TRANS = 'N' or 'n', K specifies the number",
       "          of  columns of the matrix A, and on entry with TRANS = 'T'",
       "          or 't', K specifies the number of rows of the matrix A. K",
       "          must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is REAL array of DIMENSION (LDA,ka)",
       "          where KA",
       "          is K  when TRANS = 'N' or 'n', and is N otherwise. Before",
       "          entry with TRANS = 'N' or 'n', the leading N--by--K part of",
       "          the array A must contain the matrix A, otherwise the leading",
       "          K--by--N part of the array A must contain the matrix A.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'",
       "          then  LDA must be at least  max( 1, n ), otherwise  LDA must",
       "          be at least  max( 1, k ).",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL",
       "          On entry, BETA specifies the scalar beta.",
       "          Unchanged on exit."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (NT)",
       "          NT = N*(N+1)/2. On entry, the symmetric matrix C in RFP",
       "          Format. RFP Format is described by TRANSR, UPLO and N."]}},
 "zpprfs"=>
  {"summary"=>
    ["ZPPRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian positive definite",
     "and packed, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the Hermitian matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "AFP"=>
      ["[in]",
       "         AFP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H, as computed by DPPTRF/ZPPTRF,",
       "         packed columnwise in a linear array in the same format as A",
       "         (see AP)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by ZPPTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sspgst"=>
  {"summary"=>
    ["SSPGST reduces a real symmetric-definite generalized eigenproblem",
     "to standard form, using packed storage.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L.",
     "B must have been previously factorized as U**T*U or L*L**T by SPPTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T);",
       "         = 2 or 3: compute U*A*U**T or L**T*A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored and B is factored as",
       "                 U**T*U;",
       "         = 'L':  Lower triangle of A is stored and B is factored as",
       "                 L*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "BP"=>
      ["[in]",
       "         BP is REAL array, dimension (N*(N+1)/2)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         stored in the same format as A, as returned by SPPTRF."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cggev"=>
  {"summary"=>
    ["CGGEV computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, and optionally, the left and/or",
     "right generalized eigenvectors.",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right generalized eigenvector v(j) corresponding to the",
     "generalized eigenvalue lambda(j) of (A,B) satisfies",
     "             A * v(j) = lambda(j) * B * v(j).",
     "The left generalized eigenvector u(j) corresponding to the",
     "generalized eigenvalues lambda(j) of (A,B) satisfies",
     "             u(j)**H * A = lambda(j) * u(j)**H * B",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX array, dimension (N)",
       "         On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the",
       "         generalized eigenvalues.",
       "         Note: the quotients ALPHA(j)/BETA(j) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio alpha/beta.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is COMPLEX array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left generalized eigenvectors u(j) are",
       "         stored one after another in the columns of VL, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is COMPLEX array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right generalized eigenvectors v(j) are",
       "         stored one after another in the columns of VR, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,2*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (8*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         =1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHA(j) and BETA(j) should be",
       "               correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other then QZ iteration failed in SHGEQZ,",
       "               =N+2: error return from STGEVC."]}},
 "ilaclc"=>
  {"summary"=>["ILACLC scans A for its last non-zero column."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."]}},
 "sgtsv"=>
  {"summary"=>
    ["SGTSV  solves the equation",
     "   A*X = B,",
     "where A is an n by n tridiagonal matrix, by Gaussian elimination with",
     "partial pivoting.",
     "Note that the equation  A**T*X = B  may be solved by interchanging the",
     "order of the arguments DU and DL."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in,out]",
       "         DL is REAL array, dimension (N-1)",
       "         On entry, DL must contain the (n-1) sub-diagonal elements of",
       "         A.",
       "         On exit, DL is overwritten by the (n-2) elements of the",
       "         second super-diagonal of the upper triangular matrix U from",
       "         the LU factorization of A, in DL(1), ..., DL(n-2)."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, D must contain the diagonal elements of A.",
       "         On exit, D is overwritten by the n diagonal elements of U."],
     "DU"=>
      ["[in,out]",
       "         DU is REAL array, dimension (N-1)",
       "         On entry, DU must contain the (n-1) super-diagonal elements",
       "         of A.",
       "         On exit, DU is overwritten by the (n-1) elements of the first",
       "         super-diagonal of U."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N by NRHS matrix of right hand side matrix B.",
       "         On exit, if INFO = 0, the N by NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, U(i,i) is exactly zero, and the solution",
       "              has not been computed.  The factorization has not been",
       "              completed unless i = N."]}},
 "sgesvdx"=>
  {"summary"=>
    [" SGESVDX computes the singular value decomposition (SVD) of a real",
     " M-by-N matrix A, optionally computing the left and/or right singular",
     " vectors. The SVD is written",
     "     A = U * SIGMA * transpose(V)",
     " where SIGMA is an M-by-N matrix which is zero except for its",
     " min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and",
     " V is an N-by-N orthogonal matrix.  The diagonal elements of SIGMA",
     " are the singular values of A; they are real and non-negative, and",
     " are returned in descending order.  The first min(m,n) columns of",
     " U and V are the left and right singular vectors of A.",
     " SGESVDX uses an eigenvalue problem for obtaining the SVD, which",
     " allows for the computation of a subset of singular values and",
     " vectors. See SBDSVDX for details.",
     " Note that the routine returns V**T, not V."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'V':  the first min(m,n) columns of U (the left singular",
       "                 vectors) or as specified by RANGE are returned in",
       "                 the array U;",
       "         = 'N':  no columns of U (no left singular vectors) are",
       "                 computed."],
     "JOBVT"=>
      ["[in]",
       "         JOBVT is CHARACTER*1",
       "          Specifies options for computing all or part of the matrix",
       "          V**T:",
       "          = 'V':  the first min(m,n) rows of V**T (the right singular",
       "                  vectors) or as specified by RANGE are returned in",
       "                  the array VT;",
       "          = 'N':  no rows of V**T (no right singular vectors) are",
       "                  computed."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all singular values will be found.",
       "         = 'V': all singular values in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th singular values will be found."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the contents of A are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "NS"=>
      ["[out]",
       "         NS is INTEGER",
       "         The total number of singular values found,",
       "         0 <= NS <= min(M,N).",
       "         If RANGE = 'A', NS = min(M,N); if RANGE = 'I', NS = IU-IL+1."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is REAL array, dimension (LDU,UCOL)",
       "         If JOBU = 'V', U contains columns of U (the left singular",
       "         vectors, stored columnwise) as specified by RANGE; if",
       "         JOBU = 'N', U is not referenced.",
       "         Note: The user must ensure that UCOL >= NS; if RANGE = 'V',",
       "         the exact value of NS is not known in advance and an upper",
       "         bound must be used."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1; if",
       "         JOBU = 'V', LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is REAL array, dimension (LDVT,N)",
       "         If JOBVT = 'V', VT contains the rows of V**T (the right singular",
       "         vectors, stored rowwise) as specified by RANGE; if JOBVT = 'N',",
       "         VT is not referenced.",
       "         Note: The user must ensure that LDVT >= NS; if RANGE = 'V',",
       "         the exact value of NS is not known in advance and an upper",
       "         bound must be used."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1; if",
       "         JOBVT = 'V', LDVT >= NS (see above)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK;"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= MAX(1,MIN(M,N)*(MIN(M,N)+4)) for the paths (see",
       "         comments inside the code):",
       "            - PATH 1  (M much larger than N)",
       "            - PATH 1t (N much larger than M)",
       "         LWORK >= MAX(1,MIN(M,N)*2+MAX(M,N)) for the other paths.",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (12*MIN(M,N))",
       "         If INFO = 0, the first NS elements of IWORK are zero. If INFO > 0,",
       "         then IWORK contains the indices of the eigenvectors that failed",
       "         to converge in SBDSVDX/SSTEVX."],
     "INFO"=>
      ["[out]",
       "    INFO is INTEGER",
       "          = 0:  successful exit",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value",
       "          > 0:  if INFO = i, then i eigenvectors failed to converge",
       "                in SBDSVDX/SSTEVX.",
       "                if INFO = N*2 + 1, an internal error occurred in",
       "                SBDSVDX"]}},
 "sla_gbrcond"=>
  {"summary"=>
    ["   SLA_GBRCOND Estimates the Skeel condition number of  op(A) * op2(C)",
     "   where op2 is determined by CMODE as follows",
     "   CMODE =  1    op2(C) = C",
     "   CMODE =  0    op2(C) = I",
     "   CMODE = -1    op2(C) = inv(C)",
     "   The Skeel condition number  cond(A) = norminf( |inv(A)||A| )",
     "   is computed by computing scaling factors R such that",
     "   diag(R)*A*op2(C) is row equilibrated and computing the standard",
     "   infinity-norm condition number."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "    On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is REAL array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by SGBTRF.  U is stored as an upper triangular",
       "    band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1,",
       "    and the multipliers used during the factorization are stored",
       "    in rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by SGBTRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "CMODE"=>
      ["[in]",
       "         CMODE is INTEGER",
       "    Determines op2(C) in the formula op(A) * op2(C) as follows:",
       "    CMODE =  1    op2(C) = C",
       "    CMODE =  0    op2(C) = I",
       "    CMODE = -1    op2(C) = inv(C)"],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The vector C in the formula op(A) * op2(C)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is REAL array, dimension (5*N).",
       "    Workspace."],
     "IWORK"=>
      ["[in]",
       "         IWORK is INTEGER array, dimension (N).",
       "    Workspace."]}},
 "sgeqr2p"=>
  {"summary"=>
    ["SGEQR2P computes a QR factorization of a real m by n matrix A:",
     "A = Q * R. The diagonal entries of R are nonnegative."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(m,n) by n upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n). The diagonal entries of R",
       "         are nonnegative; the elements below the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dsyevr"=>
  {"summary"=>
    ["DSYEVR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A.  Eigenvalues and eigenvectors can be",
     "selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues.",
     "DSYEVR first reduces the matrix A to tridiagonal form T with a call",
     "to DSYTRD.  Then, whenever possible, DSYEVR calls DSTEMR to compute",
     "the eigenspectrum using Relatively Robust Representations.  DSTEMR",
     "computes eigenvalues by the dqds algorithm, while orthogonal",
     "eigenvectors are computed from various \"good\" L D L^T representations",
     "(also known as Relatively Robust Representations). Gram-Schmidt",
     "orthogonalization is avoided as far as possible. More specifically,",
     "the various steps of the algorithm are as follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "The desired accuracy of the output can be specified by the input",
     "parameter ABSTOL.",
     "For more details, see DSTEMR's documentation and:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Note 1 : DSYEVR calls DSTEMR when the full spectrum is requested",
     "on machines which conform to the ieee-754 floating point standard.",
     "DSYEVR calls DSTEBZ and SSTEIN on non-ieee machines and",
     "when partial spectrum requests are made.",
     "Normal execution of DSTEMR may create NaNs and infinities and",
     "hence may abort due to a floating point exception in environments",
     "which do not handle NaNs and infinities in the ieee standard default",
     "manner."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found.",
       "         For RANGE = 'V' or 'I' and IU - IL < N - 1, DSTEBZ and",
       "         DSTEIN are called"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3.",
       "         If high relative accuracy is important, set ABSTOL to",
       "         DLAMCH( 'Safe minimum' ).  Doing so will guarantee that",
       "         eigenvalues are computed to high relative accuracy when",
       "         possible in future releases.  The current code does not",
       "         make any guarantees about high relative accuracy, but",
       "         future releases will. See J. Barlow and J. Demmel,",
       "         \"Computing Accurate Eigensystems of Scaled Diagonally",
       "         Dominant Matrices\", LAPACK Working Note #7, for a discussion",
       "         of which matrices define their eigenvalues to high relative",
       "         accuracy."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used.",
       "         Supplying N columns is always safe."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is an output of DSTEMR (tridiagonal",
       "         matrix). The support of the eigenvectors of A is typically",
       "         1:N because of the orthogonal transformations applied by DORMTR.",
       "         Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1"],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,26*N).",
       "         For optimal efficiency, LWORK >= (NB+6)*N,",
       "         where NB is the max of the blocksize for DSYTRD and DORMTR",
       "         returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  Internal error"]}},
 "ssyconv"=>
  {"summary"=>
    ["SSYCONV convert A given by TRF into L and D and vice-versa.",
     "Get Non-diag elements of D (returned in workspace) and",
     "apply or reverse permutation done in TRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by SSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N)",
       "         E stores the supdiagonal/subdiagonal of the symmetric 1-by-1",
       "         or 2-by-2 block diagonal matrix D in LDLT."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgeql2"=>
  {"summary"=>
    ["DGEQL2 computes a QL factorization of a real m by n matrix A:",
     "A = Q * L."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, if m >= n, the lower triangle of the subarray",
       "         A(m-n+1:m,1:n) contains the n by n lower triangular matrix L;",
       "         if m <= n, the elements on and below the (n-m)-th",
       "         superdiagonal contain the m by n lower trapezoidal matrix L;",
       "         the remaining elements, with the array TAU, represent the",
       "         orthogonal matrix Q as a product of elementary reflectors",
       "         (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "ctplqt2"=>
  {"summary"=>
    ["CTPLQT2 computes a LQ a factorization of a complex \"triangular-pentagonal\"",
     "matrix C, which is composed of a triangular block A and pentagonal block B,",
     "using the compact WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of",
       "         the triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the lower trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the lower triangular M-by-M matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the lower triangular matrix L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first N-L columns",
       "         are rectangular, and the last L columns are lower trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,M)",
       "         The N-by-N upper triangular factor T of the block reflector.",
       "         See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dgghd3"=>
  {"summary"=>
    ["DGGHD3 reduces a pair of real matrices (A,B) to generalized upper",
     "Hessenberg form using orthogonal transformations, where A is a",
     "general matrix and B is upper triangular.  The form of the",
     "generalized eigenvalue problem is",
     "   A*x = lambda*B*x,",
     "and B is typically made upper triangular by computing its QR",
     "factorization and moving the orthogonal matrix Q to the left side",
     "of the equation.",
     "This subroutine simultaneously reduces A to a Hessenberg matrix H:",
     "   Q**T*A*Z = H",
     "and transforms B to another upper triangular matrix T:",
     "   Q**T*B*Z = T",
     "in order to reduce the problem to its standard form",
     "   H*y = lambda*T*y",
     "where y = Z**T*x.",
     "The orthogonal matrices Q and Z are determined as products of Givens",
     "rotations.  They may either be formed explicitly, or they may be",
     "postmultiplied into input matrices Q1 and Z1, so that",
     "     Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T",
     "     Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T",
     "If Q1 is the orthogonal matrix from the QR factorization of B in the",
     "original equation A*x = lambda*B*x, then DGGHD3 reduces the original",
     "problem to generalized Hessenberg form.",
     "This is a blocked variant of DGGHRD, using matrix-matrix",
     "multiplications for parts of the computation to enhance performance."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': do not compute Q;",
       "         = 'I': Q is initialized to the unit matrix, and the",
       "                orthogonal matrix Q is returned;",
       "         = 'V': Q must contain an orthogonal matrix Q1 on entry,",
       "                and the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': do not compute Z;",
       "         = 'I': Z is initialized to the unit matrix, and the",
       "                orthogonal matrix Z is returned;",
       "         = 'V': Z must contain an orthogonal matrix Z1 on entry,",
       "                and the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of A which are to be",
       "         reduced.  It is assumed that A is already upper triangular",
       "         in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are",
       "         normally set by a previous call to DGGBAL; otherwise they",
       "         should be set to 1 and N respectively.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         rest is set to zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the N-by-N upper triangular matrix B.",
       "         On exit, the upper triangular matrix T = Q**T B Z.  The",
       "         elements below the diagonal are set to zero."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the orthogonal matrix Q1,",
       "         typically from the QR factorization of B.",
       "         On exit, if COMPQ='I', the orthogonal matrix Q, and if",
       "         COMPQ = 'V', the product Q1*Q.",
       "         Not referenced if COMPQ='N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the orthogonal matrix Z1.",
       "         On exit, if COMPZ='I', the orthogonal matrix Z, and if",
       "         COMPZ = 'V', the product Z1*Z.",
       "         Not referenced if COMPZ='N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.",
       "         LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= 1.",
       "         For optimum performance LWORK >= 6*N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slaed7"=>
  {"summary"=>
    ["SLAED7 computes the updated eigensystem of a diagonal",
     "matrix after modification by a rank-one symmetric matrix. This",
     "routine is used only for the eigenproblem which requires all",
     "eigenvalues and optionally eigenvectors of a dense symmetric matrix",
     "that has been reduced to tridiagonal form.  SLAED1 handles",
     "the case in which all eigenvalues and eigenvectors of a symmetric",
     "tridiagonal matrix are desired.",
     "  T = Q(in) ( D(in) + RHO * Z*Z**T ) Q**T(in) = Q(out) * D(out) * Q**T(out)",
     "   where Z = Q**Tu, u is a vector of length N with ones in the",
     "   CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.",
     "   The eigenvectors of the original matrix are stored in Q, and the",
     "   eigenvalues are in D.  The algorithm consists of three stages:",
     "      The first stage consists of deflating the size of the problem",
     "      when there are multiple eigenvalues or if there is a zero in",
     "      the Z vector.  For each such occurrence the dimension of the",
     "      secular equation problem is reduced by one.  This stage is",
     "      performed by the routine SLAED8.",
     "      The second stage consists of calculating the updated",
     "      eigenvalues. This is done by finding the roots of the secular",
     "      equation via the routine SLAED4 (as called by SLAED9).",
     "      This routine also calculates the eigenvectors of the current",
     "      problem.",
     "      The final stage consists of computing the updated eigenvectors",
     "      directly using the updated eigenvalues.  The eigenvectors for",
     "      the current problem are multiplied with the eigenvectors from",
     "      the overall problem."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "         = 0:  Compute eigenvalues only.",
       "         = 1:  Compute eigenvectors of original dense symmetric matrix",
       "               also.  On entry, Q contains the orthogonal matrix used",
       "               to reduce the original matrix to tridiagonal form."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the orthogonal matrix used to reduce",
       "        the full matrix to tridiagonal form.  QSIZ >= N if ICOMPQ = 1."],
     "TLVLS"=>
      ["[in]",
       "         TLVLS is INTEGER",
       "        The total number of merging levels in the overall divide and",
       "        conquer tree."],
     "CURLVL"=>
      ["[in]",
       "         CURLVL is INTEGER",
       "        The current level in the overall merge routine,",
       "        0 <= CURLVL <= TLVLS."],
     "CURPBM"=>
      ["[in]",
       "         CURPBM is INTEGER",
       "        The current problem in the current level in the overall",
       "        merge routine (counting from upper left to lower right)."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry, the eigenvalues of the rank-1-perturbed matrix.",
       "        On exit, the eigenvalues of the repaired matrix."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ, N)",
       "        On entry, the eigenvectors of the rank-1-perturbed matrix.",
       "        On exit, the eigenvectors of the repaired tridiagonal matrix."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "INDXQ"=>
      ["[out]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        The permutation which will reintegrate the subproblem just",
       "        solved back into sorted order, i.e., D( INDXQ( I = 1, N ) )",
       "        will be in ascending order."],
     "RHO"=>
      ["[in]",
       "         RHO is REAL",
       "        The subdiagonal element used to create the rank-1",
       "        modification."],
     "CUTPNT"=>
      ["[in]",
       "         CUTPNT is INTEGER",
       "        Contains the location of the last eigenvalue in the leading",
       "        sub-matrix.  min(1,N) <= CUTPNT <= N."],
     "QSTORE"=>
      ["[in,out]",
       "         QSTORE is REAL array, dimension (N**2+1)",
       "        Stores eigenvectors of submatrices encountered during",
       "        divide and conquer, packed together. QPTR points to",
       "        beginning of the submatrices."],
     "QPTR"=>
      ["[in,out]",
       "         QPTR is INTEGER array, dimension (N+2)",
       "        List of indices pointing to beginning of submatrices stored",
       "        in QSTORE. The submatrices are numbered starting at the",
       "        bottom left of the divide and conquer tree, from left to",
       "        right and bottom to top."],
     "PRMPTR"=>
      ["[in]",
       "         PRMPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in PERM a",
       "        level's permutation is stored.  PRMPTR(i+1) - PRMPTR(i)",
       "        indicates the size of the permutation and also the size of",
       "        the full, non-deflated problem."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension (N lg N)",
       "        Contains the permutations (from deflation and sorting) to be",
       "        applied to each eigenblock."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in GIVCOL a",
       "        level's Givens rotations are stored.  GIVPTR(i+1) - GIVPTR(i)",
       "        indicates the number of Givens rotations."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension (2, N lg N)",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is REAL array, dimension (2, N lg N)",
       "        Each number indicates the S value to be used in the",
       "        corresponding Givens rotation."],
     "WORK"=>
      ["[out]", "         WORK is REAL array, dimension (3*N+2*QSIZ*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, an eigenvalue did not converge"]}},
 "dsytrf_rk"=>
  {"summary"=>
    ["DSYTRF_RK computes the factorization of a real symmetric matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension ( MAX(1,LWORK) ).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned",
       "         by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array, returns this value as the first entry of the WORK",
       "         array, and no error message related to LWORK is issued",
       "         by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "zsytrs2"=>
  {"summary"=>
    ["ZSYTRS2 solves a system of linear equations A*X = B with a real",
     "symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by ZSYTRF and converted by ZSYCONV."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZSYTRF.",
       "         Note that A is input / output. This might be counter-intuitive,",
       "         and one may think that A is input only. A is input / output. This",
       "         is because, at the start of the subroutine, we permute A in a",
       "         \"better\" form and then we permute A back to its original form at",
       "         the end."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cggbal"=>
  {"summary"=>
    ["CGGBAL balances a pair of general complex matrices (A,B).  This",
     "involves, first, permuting A and B by similarity transformations to",
     "isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N",
     "elements on the diagonal; and second, applying a diagonal similarity",
     "transformation to rows and columns ILO to IHI to make the rows",
     "and columns as close in norm as possible. Both steps are optional.",
     "Balancing may reduce the 1-norm of the matrices, and improve the",
     "accuracy of the computed eigenvalues and/or eigenvectors in the",
     "generalized eigenvalue problem A*x = lambda*B*x."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the operations to be performed on A and B:",
       "         = 'N':  none:  simply set ILO = 1, IHI = N, LSCALE(I) = 1.0",
       "                 and RSCALE(I) = 1.0 for i=1,...,N;",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the input matrix A.",
       "         On exit, A is overwritten by the balanced matrix.",
       "         If JOB = 'N', A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the input matrix B.",
       "         On exit, B is overwritten by the balanced matrix.",
       "         If JOB = 'N', B is not referenced."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are set to integers such that on exit",
       "         A(i,j) = 0 and B(i,j) = 0 if i > j and",
       "         j = 1,...,ILO-1 or i = IHI+1,...,N.",
       "         If JOB = 'N' or 'S', ILO = 1 and IHI = N."],
     "LSCALE"=>
      ["[out]",
       "         LSCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the left side of A and B.  If P(j) is the index of the",
       "         row interchanged with row j, and D(j) is the scaling factor",
       "         applied to row j, then",
       "           LSCALE(j) = P(j)    for J = 1,...,ILO-1",
       "                     = D(j)    for J = ILO,...,IHI",
       "                     = P(j)    for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "RSCALE"=>
      ["[out]",
       "         RSCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the right side of A and B.  If P(j) is the index of the",
       "         column interchanged with column j, and D(j) is the scaling",
       "         factor applied to column j, then",
       "           RSCALE(j) = P(j)    for J = 1,...,ILO-1",
       "                     = D(j)    for J = ILO,...,IHI",
       "                     = P(j)    for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (lwork)",
       "         lwork must be at least max(1,6*N) when JOB = 'S' or 'B', and",
       "         at least 1 when JOB = 'N' or 'P'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dpocon"=>
  {"summary"=>
    ["DPOCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric positive definite matrix using the",
     "Cholesky factorization A = U**T*U or A = L*L**T computed by DPOTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, as computed by DPOTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm (or infinity-norm) of the symmetric matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clascl"=>
  {"summary"=>
    ["CLASCL multiplies the M by N complex matrix A by the real scalar",
     "CTO/CFROM.  This is done without over/underflow as long as the final",
     "result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that",
     "A may be full, upper triangular, lower triangular, upper Hessenberg,",
     "or banded."],
   "param"=>
    {"TYPE"=>
      ["[in]",
       "         TYPE is CHARACTER*1",
       "         TYPE indices the storage type of the input matrix.",
       "         = 'G':  A is a full matrix.",
       "         = 'L':  A is a lower triangular matrix.",
       "         = 'U':  A is an upper triangular matrix.",
       "         = 'H':  A is an upper Hessenberg matrix.",
       "         = 'B':  A is a symmetric band matrix with lower bandwidth KL",
       "                 and upper bandwidth KU and with the only the lower",
       "                 half stored.",
       "         = 'Q':  A is a symmetric band matrix with lower bandwidth KL",
       "                 and upper bandwidth KU and with the only the upper",
       "                 half stored.",
       "         = 'Z':  A is a band matrix with lower bandwidth KL and upper",
       "                 bandwidth KU. See CGBTRF for storage details."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The lower bandwidth of A.  Referenced only if TYPE = 'B',",
       "         'Q' or 'Z'."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The upper bandwidth of A.  Referenced only if TYPE = 'B',",
       "         'Q' or 'Z'."],
     "CFROM"=>["[in]", "         CFROM is REAL"],
     "CTO"=>
      ["[in]",
       "         CTO is REAL",
       "         The matrix A is multiplied by CTO/CFROM. A(I,J) is computed",
       "         without over/underflow if the final result CTO*A(I,J)/CFROM",
       "         can be represented without over/underflow.  CFROM must be",
       "         nonzero."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The matrix to be multiplied by CTO/CFROM.  See TYPE for the",
       "         storage type."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If TYPE = 'G', 'L', 'U', 'H', LDA >= max(1,M);",
       "            TYPE = 'B', LDA >= KL+1;",
       "            TYPE = 'Q', LDA >= KU+1;",
       "            TYPE = 'Z', LDA >= 2*KL+KU+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         0  - successful exit",
       "         <0 - if INFO = -i, the i-th argument had an illegal value."]}},
 "chetf2_rook"=>
  {"summary"=>
    ["CHETF2_ROOK computes the factorization of a complex Hermitian matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method:",
     "   A = U*D*U**H  or  A = L*D*L**H",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**H is the conjugate transpose of U, and D is",
     "Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "csteqr"=>
  {"summary"=>
    ["CSTEQR computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric tridiagonal matrix using the implicit QL or QR method.",
     "The eigenvectors of a full or band complex Hermitian matrix can also",
     "be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this",
     "matrix to tridiagonal form."],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'V':  Compute eigenvalues and eigenvectors of the original",
       "                 Hermitian matrix.  On entry, Z must contain the",
       "                 unitary matrix used to reduce the original matrix",
       "                 to tridiagonal form.",
       "         = 'I':  Compute eigenvalues and eigenvectors of the",
       "                 tridiagonal matrix.  Z is initialized to the identity",
       "                 matrix."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the diagonal elements of the tridiagonal matrix.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         On entry, if  COMPZ = 'V', then Z contains the unitary",
       "         matrix used in the reduction to tridiagonal form.",
       "         On exit, if INFO = 0, then if COMPZ = 'V', Z contains the",
       "         orthonormal eigenvectors of the original Hermitian matrix,",
       "         and if COMPZ = 'I', Z contains the orthonormal eigenvectors",
       "         of the symmetric tridiagonal matrix.",
       "         If COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         eigenvectors are desired, then  LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (max(1,2*N-2))",
       "         If COMPZ = 'N', then WORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  the algorithm has failed to find all the eigenvalues in",
       "               a total of 30*N iterations; if INFO = i, then i",
       "               elements of E have not converged to zero; on exit, D",
       "               and E contain the elements of a symmetric tridiagonal",
       "               matrix which is unitarily similar to the original",
       "               matrix."]}},
 "zlangt"=>
  {"summary"=>
    ["ZLANGT  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex tridiagonal matrix A.",
     "   ZLANGT = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANGT as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANGT is",
       "         set to zero."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) sub-diagonal elements of A."],
     "D"=>
      ["[in]",
       "         D is COMPLEX*16 array, dimension (N)",
       "         The diagonal elements of A."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) super-diagonal elements of A."]}},
 "slansp"=>
  {"summary"=>
    ["SLANSP  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "real symmetric matrix A,  supplied in packed form.",
     "   SLANSP = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANSP as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is supplied.",
       "         = 'U':  Upper triangular part of A is supplied",
       "         = 'L':  Lower triangular part of A is supplied"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, SLANSP is",
       "         set to zero."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "zhpgvx"=>
  {"summary"=>
    ["ZHPGVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be Hermitian, stored in packed format, and B is also",
     "positive definite.  Eigenvalues and eigenvectors can be selected by",
     "specifying either a range of values or a range of indices for the",
     "desired eigenvalues."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H, in the same storage",
       "         format as B."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AP to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  ZPPTRF or ZHPEVX returned an error code:",
       "            <= N:  if INFO = i, ZHPEVX failed to converge;",
       "                   i eigenvectors failed to converge.  Their indices",
       "                   are stored in array IFAIL.",
       "            > N:   if INFO = N + i, for 1 <= i <= n, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "dpoequb"=>
  {"summary"=>
    ["DPOEQUB computes row and column scalings intended to equilibrate a",
     "symmetric positive definite matrix A and reduce its condition number",
     "(with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings.",
     "This routine differs from DPOEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled diagonal entries are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The N-by-N symmetric positive definite matrix whose scaling",
       "         factors are to be computed.  Only the diagonal elements of A",
       "         are referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is DOUBLE PRECISION",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "ssytrs_aa"=>
  {"summary"=>
    ["SSYTRS_AA solves a system of linear equations A*X = B with a real",
     "symmetric matrix A using the factorization A = U*T*U**T or",
     "A = L*T*L**T computed by SSYTRF_AA."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*T*U**T;",
       "         = 'L':  Lower triangular, form is A = L*T*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         Details of factors computed by SSYTRF_AA."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges as computed by SSYTRF_AA."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[in]", "         WORK is DOUBLE array, dimension (MAX(1,LWORK))"],
     "LWORK"=>["[in]", "         LWORK is INTEGER, LWORK >= MAX(1,3*N-2)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clartg"=>
  {"summary"=>
    ["CLARTG generates a plane rotation so that",
     "   [  CS  SN  ]     [ F ]     [ R ]",
     "   [  __      ]  .  [   ]  =  [   ]   where CS**2 + |SN|**2 = 1.",
     "   [ -SN  CS  ]     [ G ]     [ 0 ]",
     "This is a faster version of the BLAS1 routine CROTG, except for",
     "the following differences:",
     "   F and G are unchanged on return.",
     "   If G=0, then CS=1 and SN=0.",
     "   If F=0, then CS=0 and SN is chosen so that R is real."],
   "param"=>
    {"F"=>
      ["[in]",
       "         F is COMPLEX",
       "         The first component of vector to be rotated."],
     "G"=>
      ["[in]",
       "         G is COMPLEX",
       "         The second component of vector to be rotated."],
     "CS"=>
      ["[out]", "         CS is REAL", "         The cosine of the rotation."],
     "SN"=>
      ["[out]",
       "         SN is COMPLEX",
       "         The sine of the rotation."],
     "R"=>
      ["[out]",
       "         R is COMPLEX",
       "         The nonzero component of the rotated vector."]}},
 "dorm2l"=>
  {"summary"=>
    ["DORM2L overwrites the general real m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**T * C  if SIDE = 'L' and TRANS = 'T', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**T if SIDE = 'R' and TRANS = 'T',",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by DGEQLF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left",
       "         = 'R': apply Q or Q**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'T': apply Q**T (Transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGEQLF in the last k columns of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGEQLF."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zhbev_2stage"=>
  {"summary"=>
    ["ZHBEV_2STAGE computes all the eigenvalues and, optionally, eigenvectors of",
     "a complex Hermitian band matrix A using the 2stage technique for",
     "the reduction to tridiagonal."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension LWORK",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (max(1,3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dlaswlq"=>
  {"summary"=>
    ["         DLASWLQ computes a blocked Short-Wide LQ factorization of a",
     "         M-by-N matrix A, where N >= M:",
     "         A = L * Q"],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= M >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         M >= MB >= 1"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         NB > M."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and bleow the diagonal",
       "         of the array contain the N-by-N lower triangular matrix L;",
       "         the elements above the diagonal represent Q by the rows",
       "         of blocked V (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array,",
       "         dimension (LDT, N * Number_of_row_blocks)",
       "         where Number_of_row_blocks = CEIL((N-M)/(NB-M))",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.",
       "         See Further Details below."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>
      ["[out]",
       "        (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         The dimension of the array WORK.  LWORK >= MB*M.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zla_herfsx_extended"=>
  {"summary"=>
    ["ZLA_HERFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by ZHERFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by ZHETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by ZHETRF."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension",
       "                   (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by ZHETRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by ZLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is DOUBLE PRECISION array, dimension (N)",
       "    Workspace."],
     "DY"=>
      ["[in]",
       "         DY is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is DOUBLE PRECISION",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is DOUBLE PRECISION",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to ZLA_HERFSX_EXTENDED had an illegal",
       "            value"]}},
 "dlaqsp"=>
  {"summary"=>
    ["DLAQSP equilibrates a symmetric matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the equilibrated matrix:  diag(S) * A * diag(S), in",
       "         the same storage format as A."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is DOUBLE PRECISION",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "cgeqr2"=>
  {"summary"=>
    ["CGEQR2 computes a QR factorization of a complex m by n matrix A:",
     "A = Q * R."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(m,n) by n upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n); the elements below the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "ztrevc"=>
  {"summary"=>
    ["ZTREVC computes some or all of the right and/or left eigenvectors of",
     "a complex upper triangular matrix T.",
     "Matrices of this type are produced by the Schur factorization of",
     "a complex general matrix:  A = Q*T*Q**H, as computed by ZHSEQR.",
     "The right eigenvector x and the left eigenvector y of T corresponding",
     "to an eigenvalue w are defined by:",
     "             T*x = w*x,     (y**H)*T = w*(y**H)",
     "where y**H denotes the conjugate transpose of the vector y.",
     "The eigenvalues are not input to this routine, but are read directly",
     "from the diagonal of T.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an",
     "input matrix.  If Q is the unitary factor that reduces a matrix A to",
     "Schur form T, then Q*X and Q*Y are the matrices of right and left",
     "eigenvectors of A."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  compute right eigenvectors only;",
       "         = 'L':  compute left eigenvectors only;",
       "         = 'B':  compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A':  compute all right and/or left eigenvectors;",
       "         = 'B':  compute all right and/or left eigenvectors,",
       "                 backtransformed using the matrices supplied in",
       "                 VR and/or VL;",
       "         = 'S':  compute selected right and/or left eigenvectors,",
       "                 as indicated by the logical array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenvectors to be",
       "         computed.",
       "         The eigenvector corresponding to the j-th eigenvalue is",
       "         computed if SELECT(j) = .TRUE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in,out]",
       "         T is COMPLEX*16 array, dimension (LDT,N)",
       "         The upper triangular matrix T.  T is modified, but restored",
       "         on exit."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is COMPLEX*16 array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Q of",
       "         Schur vectors returned by ZHSEQR).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VL, in the same order as their",
       "                          eigenvalues.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1, and if",
       "         SIDE = 'L' or 'B', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is COMPLEX*16 array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Q of",
       "         Schur vectors returned by ZHSEQR).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*X;",
       "         if HOWMNY = 'S', the right eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VR, in the same order as their",
       "                          eigenvalues.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1, and if",
       "         SIDE = 'R' or 'B'; LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.  If HOWMNY = 'A' or 'B', M",
       "         is set to N.  Each selected eigenvector occupies one",
       "         column."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dtptri"=>
  {"summary"=>
    ["DTPTRI computes the inverse of a real upper or lower triangular",
     "matrix A stored in packed format."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangular matrix A, stored",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*((2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same packed storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, A(i,i) is exactly zero.  The triangular",
       "               matrix is singular and its inverse can not be computed."]}},
 "cgemlq"=>
  {"summary"=>
    ["    CGEMLQ overwrites the general real M-by-N matrix C with",
     "                     SIDE = 'L'     SIDE = 'R'",
     "     TRANS = 'N':      Q * C          C * Q",
     "     TRANS = 'C':      Q**H * C       C * Q**H",
     "     where Q is a complex unitary matrix defined as the product",
     "     of blocked elementary reflectors computed by short wide",
     "     LQ factorization (CGELQ)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         Part of the data structure to represent Q as returned by CGELQ."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension (MAX(5,TSIZE)).",
       "         Part of the data structure to represent Q as returned by CGELQ."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         The dimension of the array T. TSIZE >= 5."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]", "        (workspace) COMPLEX array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed. The routine",
       "         only calculates the size of the WORK array, returns this",
       "         value as WORK(1), and no error message related to WORK ",
       "         is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ctbrfs"=>
  {"summary"=>
    ["CTBRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular band",
     "coefficient matrix.",
     "The solution matrix X must be computed by CTBTRS or some other",
     "means before entering this routine.  CTBRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zpotf2"=>
  {"summary"=>
    ["ZPOTF2 computes the Cholesky factorization of a complex Hermitian",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**H * U ,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**H *U  or A = L*L**H."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite, and the factorization could not be",
       "              completed."]}},
 "dlasd8"=>
  {"summary"=>
    ["DLASD8 finds the square roots of the roots of the secular equation,",
     "as defined by the values in DSIGMA and Z. It makes the appropriate",
     "calls to DLASD4, and stores, for each  element in D, the distance",
     "to its two nearest poles (elements in DSIGMA). It also updates",
     "the arrays VF and VL, the first and last components of all the",
     "right singular vectors of the original bidiagonal matrix.",
     "DLASD8 is called from DLASD6."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "         Specifies whether singular vectors are to be computed in",
       "         factored form in the calling routine:",
       "         = 0: Compute singular values only.",
       "         = 1: Compute singular vectors in factored form as well."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of terms in the rational function to be solved",
       "         by DLASD4.  K >= 1."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension ( K )",
       "         On output, D contains the updated singular values."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension ( K )",
       "         On entry, the first K elements of this array contain the",
       "         components of the deflation-adjusted updating row vector.",
       "         On exit, Z is updated."],
     "VF"=>
      ["[in,out]",
       "         VF is DOUBLE PRECISION array, dimension ( K )",
       "         On entry, VF contains  information passed through DBEDE8.",
       "         On exit, VF contains the first K components of the first",
       "         components of all right singular vectors of the bidiagonal",
       "         matrix."],
     "VL"=>
      ["[in,out]",
       "         VL is DOUBLE PRECISION array, dimension ( K )",
       "         On entry, VL contains  information passed through DBEDE8.",
       "         On exit, VL contains the first K components of the last",
       "         components of all right singular vectors of the bidiagonal",
       "         matrix."],
     "DIFL"=>
      ["[out]",
       "         DIFL is DOUBLE PRECISION array, dimension ( K )",
       "         On exit, DIFL(I) = D(I) - DSIGMA(I)."],
     "DIFR"=>
      ["[out]",
       "         DIFR is DOUBLE PRECISION array,",
       "                  dimension ( LDDIFR, 2 ) if ICOMPQ = 1 and",
       "                  dimension ( K ) if ICOMPQ = 0.",
       "         On exit, DIFR(I,1) = D(I) - DSIGMA(I+1), DIFR(K,1) is not",
       "         defined and will not be referenced.",
       "         If ICOMPQ = 1, DIFR(1:K,2) is an array containing the",
       "         normalizing factors for the right singular vector matrix."],
     "LDDIFR"=>
      ["[in]",
       "         LDDIFR is INTEGER",
       "         The leading dimension of DIFR, must be at least K."],
     "DSIGMA"=>
      ["[in,out]",
       "         DSIGMA is DOUBLE PRECISION array, dimension ( K )",
       "         On entry, the first K elements of this array contain the old",
       "         roots of the deflated updating problem.  These are the poles",
       "         of the secular equation.",
       "         On exit, the elements of DSIGMA may be very slightly altered",
       "         in value."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension at least 3 * K"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, a singular value did not converge"]}},
 "zhegvx"=>
  {"summary"=>
    ["ZHEGVX computes selected eigenvalues, and optionally, eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be Hermitian and B is also positive definite.",
     "Eigenvalues and eigenvectors can be selected by specifying either a",
     "range of values or a range of indices for the desired eigenvalues."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit,  the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the Hermitian matrix B.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of B contains the",
       "         upper triangular part of the matrix B.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of B contains",
       "         the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing C to tridiagonal form, where C is the symmetric",
       "         matrix of the standard symmetric problem to which the",
       "         generalized problem is transformed.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,2*N).",
       "         For optimal efficiency, LWORK >= (NB+1)*N,",
       "         where NB is the blocksize for ZHETRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  ZPOTRF or ZHEEVX returned an error code:",
       "            <= N:  if INFO = i, ZHEEVX failed to converge;",
       "                   i eigenvectors failed to converge.  Their indices",
       "                   are stored in array IFAIL.",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "zlalsd"=>
  {"summary"=>
    ["ZLALSD uses the singular value decomposition of A to solve the least",
     "squares problem of finding X to minimize the Euclidean norm of each",
     "column of A*X-B, where A is N-by-N upper bidiagonal, and X and B",
     "are N-by-NRHS. The solution X overwrites B.",
     "The singular values of A smaller than RCOND times the largest",
     "singular value are treated as zero in solving the least squares",
     "problem; in this case a minimum norm solution is returned.",
     "The actual singular values are returned in D in ascending order.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "        = 'U': D and E define an upper bidiagonal matrix.",
       "        = 'L': D and E define a  lower bidiagonal matrix."],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        The maximum size of the subproblems at the bottom of the",
       "        computation tree."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the  bidiagonal matrix.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B. NRHS must be at least 1."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        On entry D contains the main diagonal of the bidiagonal",
       "        matrix. On exit, if INFO = 0, D contains its singular values."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "        Contains the super-diagonal entries of the bidiagonal matrix.",
       "        On exit, E has been destroyed."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "        On input, B contains the right hand sides of the least",
       "        squares problem. On output, B contains the solution X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B in the calling subprogram.",
       "        LDB must be at least max(1,N)."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "        The singular values of A less than or equal to RCOND times",
       "        the largest singular value are treated as zero in solving",
       "        the least squares problem. If RCOND is negative,",
       "        machine precision is used instead.",
       "        For example, if diag(S)*X=B were the least squares problem,",
       "        where diag(S) is a diagonal matrix of singular values, the",
       "        solution would be X(i) = B(i) / S(i) if S(i) is greater than",
       "        RCOND*max(S), and X(i) = 0 if S(i) is less than or equal to",
       "        RCOND*max(S)."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "        The number of singular values of A greater than RCOND times",
       "        the largest singular value."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension at least",
       "        (N * NRHS)."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension at least",
       "        (9*N + 2*N*SMLSIZ + 8*N*NLVL + 3*SMLSIZ*NRHS +",
       "        MAX( (SMLSIZ+1)**2, N*(1+NRHS) + 2*NRHS ),",
       "        where",
       "        NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 )"],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension at least",
       "        (3*N*NLVL + 11*N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit.",
       "        < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "        > 0:  The algorithm failed to compute a singular value while",
       "              working on the submatrix lying in rows and columns",
       "              INFO/(N+1) through MOD(INFO,N+1)."]}},
 "zhbev"=>
  {"summary"=>
    ["ZHBEV computes all the eigenvalues and, optionally, eigenvectors of",
     "a complex Hermitian band matrix A."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (max(1,3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dgerfs"=>
  {"summary"=>
    ["DGERFS improves the computed solution to a system of linear",
     "equations and provides error bounds and backward error estimates for",
     "the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The original N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by DGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from DGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by DGETRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlag2c"=>
  {"summary"=>
    ["ZLAG2C converts a COMPLEX*16 matrix, SA, to a COMPLEX matrix, A.",
     "RMAX is the overflow for the SINGLE PRECISION arithmetic",
     "ZLAG2C checks that all the entries of A are between -RMAX and",
     "RMAX. If not the conversion is aborted and a flag is raised.",
     "This is an auxiliary routine so there is no argument checking."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of lines of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N coefficient matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "SA"=>
      ["[out]",
       "         SA is COMPLEX array, dimension (LDSA,N)",
       "         On exit, if INFO=0, the M-by-N coefficient matrix SA; if",
       "         INFO>0, the content of SA is unspecified."],
     "LDSA"=>
      ["[in]",
       "         LDSA is INTEGER",
       "         The leading dimension of the array SA.  LDSA >= max(1,M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         = 1:  an entry of the matrix A is greater than the SINGLE",
       "               PRECISION overflow threshold, in this case, the content",
       "               of SA in exit is unspecified."]}},
 "ctfttr"=>
  {"summary"=>
    ["CTFTTR copies a triangular matrix A from rectangular full packed",
     "format (TF) to standard full format (TR)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF is in Normal format;",
       "         = 'C':  ARF is in Conjugate-transpose format;"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "ARF"=>
      ["[in]",
       "         ARF is COMPLEX array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "A"=>
      ["[out]",
       "         A is COMPLEX array, dimension ( LDA, N )",
       "         On exit, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dormr2"=>
  {"summary"=>
    ["DORMR2 overwrites the general real m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**T* C  if SIDE = 'L' and TRANS = 'T', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**T if SIDE = 'R' and TRANS = 'T',",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by DGERQF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left",
       "         = 'R': apply Q or Q**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'T': apply Q' (Transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGERQF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGERQF."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "cgtsvx"=>
  {"summary"=>
    ["CGTSVX uses the LU factorization to compute the solution to a complex",
     "system of linear equations A * X = B, A**T * X = B, or A**H * X = B,",
     "where A is a tridiagonal matrix of order N and X and B are N-by-NRHS",
     "matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "dlaeda"=>
  {"summary"=>
    ["DLAEDA computes the Z vector corresponding to the merge step in the",
     "CURLVLth step of the merge process with TLVLS steps for the CURPBMth",
     "problem."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "TLVLS"=>
      ["[in]",
       "         TLVLS is INTEGER",
       "        The total number of merging levels in the overall divide and",
       "        conquer tree."],
     "CURLVL"=>
      ["[in]",
       "         CURLVL is INTEGER",
       "        The current level in the overall merge routine,",
       "        0 <= curlvl <= tlvls."],
     "CURPBM"=>
      ["[in]",
       "         CURPBM is INTEGER",
       "        The current problem in the current level in the overall",
       "        merge routine (counting from upper left to lower right)."],
     "PRMPTR"=>
      ["[in]",
       "         PRMPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in PERM a",
       "        level's permutation is stored.  PRMPTR(i+1) - PRMPTR(i)",
       "        indicates the size of the permutation and incidentally the",
       "        size of the full, non-deflated problem."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension (N lg N)",
       "        Contains the permutations (from deflation and sorting) to be",
       "        applied to each eigenblock."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in GIVCOL a",
       "        level's Givens rotations are stored.  GIVPTR(i+1) - GIVPTR(i)",
       "        indicates the number of Givens rotations."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension (2, N lg N)",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is DOUBLE PRECISION array, dimension (2, N lg N)",
       "        Each number indicates the S value to be used in the",
       "        corresponding Givens rotation."],
     "Q"=>
      ["[in]",
       "         Q is DOUBLE PRECISION array, dimension (N**2)",
       "        Contains the square eigenblocks from previous levels, the",
       "        starting positions for blocks are given by QPTR."],
     "QPTR"=>
      ["[in]",
       "         QPTR is INTEGER array, dimension (N+2)",
       "        Contains a list of pointers which indicate where in Q an",
       "        eigenblock is stored.  SQRT( QPTR(i+1) - QPTR(i) ) indicates",
       "        the size of the block."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (N)",
       "        On output this vector contains the updating vector (the last",
       "        row of the first sub-eigenvector matrix and the first row of",
       "        the second sub-eigenvector matrix)."],
     "ZTEMP"=>
      ["[out]", "         ZTEMP is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "claic1"=>
  {"summary"=>
    ["CLAIC1 applies one step of incremental condition estimation in",
     "its simplest version:",
     "Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j",
     "lower triangular matrix L, such that",
     "         twonorm(L*x) = sest",
     "Then CLAIC1 computes sestpr, s, c such that",
     "the vector",
     "                [ s*x ]",
     "         xhat = [  c  ]",
     "is an approximate singular vector of",
     "                [ L      0  ]",
     "         Lhat = [ w**H gamma ]",
     "in the sense that",
     "         twonorm(Lhat*xhat) = sestpr.",
     "Depending on JOB, an estimate for the largest or smallest singular",
     "value is computed.",
     "Note that [s c]**H and sestpr**2 is an eigenpair of the system",
     "    diag(sest*sest, 0) + [alpha  gamma] * [ conjg(alpha) ]",
     "                                          [ conjg(gamma) ]",
     "where  alpha =  x**H*w."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is INTEGER",
       "         = 1: an estimate for the largest singular value is computed.",
       "         = 2: an estimate for the smallest singular value is computed."],
     "J"=>["[in]", "         J is INTEGER", "         Length of X and W"],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension (J)",
       "         The j-vector x."],
     "SEST"=>
      ["[in]",
       "         SEST is REAL",
       "         Estimated singular value of j by j matrix L"],
     "W"=>
      ["[in]",
       "         W is COMPLEX array, dimension (J)",
       "         The j-vector w."],
     "GAMMA"=>
      ["[in]",
       "         GAMMA is COMPLEX",
       "         The diagonal element gamma."],
     "SESTPR"=>
      ["[out]",
       "         SESTPR is REAL",
       "         Estimated singular value of (j+1) by (j+1) matrix Lhat."],
     "S"=>
      ["[out]",
       "         S is COMPLEX",
       "         Sine needed in forming xhat."],
     "C"=>
      ["[out]",
       "         C is COMPLEX",
       "         Cosine needed in forming xhat."]}},
 "zlar1v"=>
  {"summary"=>
    ["ZLAR1V computes the (scaled) r-th column of the inverse of",
     "the sumbmatrix in rows B1 through BN of the tridiagonal matrix",
     "L D L**T - sigma I. When sigma is close to an eigenvalue, the",
     "computed vector is an accurate eigenvector. Usually, r corresponds",
     "to the index where the eigenvector is largest in magnitude.",
     "The following steps accomplish this computation :",
     "(a) Stationary qd transform,  L D L**T - sigma I = L(+) D(+) L(+)**T,",
     "(b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,",
     "(c) Computation of the diagonal elements of the inverse of",
     "    L D L**T - sigma I by combining the above transforms, and choosing",
     "    r as the index where the diagonal of the inverse is (one of the)",
     "    largest in magnitude.",
     "(d) Computation of the (scaled) r-th column of the inverse using the",
     "    twisted factorization obtained by combining the top part of the",
     "    the stationary and the bottom part of the progressive transform."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix L D L**T."],
     "B1"=>
      ["[in]",
       "         B1 is INTEGER",
       "          First index of the submatrix of L D L**T."],
     "BN"=>
      ["[in]",
       "         BN is INTEGER",
       "          Last index of the submatrix of L D L**T."],
     "LAMBDA"=>
      ["[in]",
       "         LAMBDA is DOUBLE PRECISION",
       "          The shift. In order to compute an accurate eigenvector,",
       "          LAMBDA should be a good approximation to an eigenvalue",
       "          of L D L**T."],
     "L"=>
      ["[in]",
       "         L is DOUBLE PRECISION array, dimension (N-1)",
       "          The (n-1) subdiagonal elements of the unit bidiagonal matrix",
       "          L, in elements 1 to N-1."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "          The n diagonal elements of the diagonal matrix D."],
     "LD"=>
      ["[in]",
       "         LD is DOUBLE PRECISION array, dimension (N-1)",
       "          The n-1 elements L(i)*D(i)."],
     "LLD"=>
      ["[in]",
       "         LLD is DOUBLE PRECISION array, dimension (N-1)",
       "          The n-1 elements L(i)*L(i)*D(i)."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "          The minimum pivot in the Sturm sequence."],
     "GAPTOL"=>
      ["[in]",
       "         GAPTOL is DOUBLE PRECISION",
       "          Tolerance that indicates when eigenvector entries are negligible",
       "          w.r.t. their contribution to the residual."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (N)",
       "          On input, all entries of Z must be set to 0.",
       "          On output, Z contains the (scaled) r-th column of the",
       "          inverse. The scaling is such that Z(R) equals 1."],
     "WANTNC"=>
      ["[in]",
       "         WANTNC is LOGICAL",
       "          Specifies whether NEGCNT has to be computed."],
     "NEGCNT"=>
      ["[out]",
       "         NEGCNT is INTEGER",
       "          If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin",
       "          in the  matrix factorization L D L**T, and NEGCNT = -1 otherwise."],
     "ZTZ"=>
      ["[out]",
       "         ZTZ is DOUBLE PRECISION",
       "          The square of the 2-norm of Z."],
     "MINGMA"=>
      ["[out]",
       "         MINGMA is DOUBLE PRECISION",
       "          The reciprocal of the largest (in magnitude) diagonal",
       "          element of the inverse of L D L**T - sigma I."],
     "R"=>
      ["[in,out]",
       "         R is INTEGER",
       "          The twist index for the twisted factorization used to",
       "          compute Z.",
       "          On input, 0 <= R <= N. If R is input as 0, R is set to",
       "          the index where (L D L**T - sigma I)^{-1} is largest",
       "          in magnitude. If 1 <= R <= N, R is unchanged.",
       "          On output, R contains the twist index used to compute Z.",
       "          Ideally, R designates the position of the maximum entry in the",
       "          eigenvector."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension (2)",
       "          The support of the vector in Z, i.e., the vector Z is",
       "          nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 )."],
     "NRMINV"=>
      ["[out]",
       "         NRMINV is DOUBLE PRECISION",
       "          NRMINV = 1/SQRT( ZTZ )"],
     "RESID"=>
      ["[out]",
       "         RESID is DOUBLE PRECISION",
       "          The residual of the FP vector.",
       "          RESID = ABS( MINGMA )/SQRT( ZTZ )"],
     "RQCORR"=>
      ["[out]",
       "         RQCORR is DOUBLE PRECISION",
       "          The Rayleigh Quotient correction to LAMBDA.",
       "          RQCORR = MINGMA*TMP"],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"]}},
 "ssyswapr"=>
  {"summary"=>
    ["SSYSWAPR applies an elementary permutation on the rows and the columns of",
     "a symmetric matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by SSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "I1"=>
      ["[in]",
       "         I1 is INTEGER",
       "         Index of the first row to swap"],
     "I2"=>
      ["[in]",
       "         I2 is INTEGER",
       "         Index of the second row to swap"]}},
 "dtplqt2"=>
  {"summary"=>
    ["DTPLQT2 computes a LQ a factorization of a real \"triangular-pentagonal\"",
     "matrix C, which is composed of a triangular block A and pentagonal block B,",
     "using the compact WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of",
       "         the triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the lower trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the lower triangular M-by-M matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the lower triangular matrix L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first N-L columns",
       "         are rectangular, and the last L columns are lower trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,M)",
       "         The N-by-N upper triangular factor T of the block reflector.",
       "         See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "cheswapr"=>
  {"summary"=>
    ["CHESWAPR applies an elementary permutation on the rows and the columns of",
     "a hermitian matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "I1"=>
      ["[in]",
       "         I1 is INTEGER",
       "         Index of the first row to swap"],
     "I2"=>
      ["[in]",
       "         I2 is INTEGER",
       "         Index of the second row to swap"]}},
 "cgesv"=>
  {"summary"=>
    ["CGESV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N matrix and X and B are N-by-NRHS matrices.",
     "The LU decomposition with partial pivoting and row interchanges is",
     "used to factor A as",
     "   A = P * L * U,",
     "where P is a permutation matrix, L is unit lower triangular, and U is",
     "upper triangular.  The factored form of A is then used to solve the",
     "system of equations A * X = B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the N-by-N coefficient matrix A.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices that define the permutation matrix P;",
       "         row i of the matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS matrix of right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero.  The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, so the solution could not be computed."]}},
 "dlasd1"=>
  {"summary"=>
    ["DLASD1 computes the SVD of an upper bidiagonal N-by-M matrix B,",
     "where N = NL + NR + 1 and M = N + SQRE. DLASD1 is called from DLASD0.",
     "A related subroutine DLASD7 handles the case in which the singular",
     "values (and the singular vectors in factored form) are desired.",
     "DLASD1 computes the SVD as follows:",
     "              ( D1(in)    0    0       0 )",
     "  B = U(in) * (   Z1**T   a   Z2**T    b ) * VT(in)",
     "              (   0       0   D2(in)   0 )",
     "    = U(out) * ( D(out) 0) * VT(out)",
     "where Z**T = (Z1**T a Z2**T b) = u**T VT**T, and u is a vector of dimension M",
     "with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros",
     "elsewhere; and the entry b is empty if SQRE = 0.",
     "The left singular vectors of the original matrix are stored in U, and",
     "the transpose of the right singular vectors are stored in VT, and the",
     "singular values are in D.  The algorithm consists of three stages:",
     "   The first stage consists of deflating the size of the problem",
     "   when there are multiple singular values or when there are zeros in",
     "   the Z vector.  For each such occurrence the dimension of the",
     "   secular equation problem is reduced by one.  This stage is",
     "   performed by the routine DLASD2.",
     "   The second stage consists of calculating the updated",
     "   singular values. This is done by finding the square roots of the",
     "   roots of the secular equation via the routine DLASD4 (as called",
     "   by DLASD3). This routine also calculates the singular vectors of",
     "   the current problem.",
     "   The final stage consists of computing the updated singular vectors",
     "   directly using the updated singular values.  The singular vectors",
     "   for the current problem are multiplied with the singular vectors",
     "   from the overall problem."],
   "param"=>
    {"NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block.  NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block.  NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has row dimension N = NL + NR + 1,",
       "        and column dimension M = N + SQRE."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array,",
       "                       dimension (N = NL+NR+1).",
       "        On entry D(1:NL,1:NL) contains the singular values of the",
       "        upper block; and D(NL+2:N) contains the singular values of",
       "        the lower block. On exit D(1:N) contains the singular values",
       "        of the modified matrix."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is DOUBLE PRECISION",
       "        Contains the diagonal element associated with the added row."],
     "BETA"=>
      ["[in,out]",
       "         BETA is DOUBLE PRECISION",
       "        Contains the off-diagonal element associated with the added",
       "        row."],
     "U"=>
      ["[in,out]",
       "         U is DOUBLE PRECISION array, dimension(LDU,N)",
       "        On entry U(1:NL, 1:NL) contains the left singular vectors of",
       "        the upper block; U(NL+2:N, NL+2:N) contains the left singular",
       "        vectors of the lower block. On exit U contains the left",
       "        singular vectors of the bidiagonal matrix."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "        The leading dimension of the array U.  LDU >= max( 1, N )."],
     "VT"=>
      ["[in,out]",
       "         VT is DOUBLE PRECISION array, dimension(LDVT,M)",
       "        where M = N + SQRE.",
       "        On entry VT(1:NL+1, 1:NL+1)**T contains the right singular",
       "        vectors of the upper block; VT(NL+2:M, NL+2:M)**T contains",
       "        the right singular vectors of the lower block. On exit",
       "        VT**T contains the right singular vectors of the",
       "        bidiagonal matrix."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "        The leading dimension of the array VT.  LDVT >= max( 1, M )."],
     "IDXQ"=>
      ["[in,out]",
       "         IDXQ is INTEGER array, dimension(N)",
       "        This contains the permutation which will reintegrate the",
       "        subproblem just solved back into sorted order, i.e.",
       "        D( IDXQ( I = 1, N ) ) will be in ascending order."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension( 4 * N )"],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension( 3*M**2 + 2*M )"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, a singular value did not converge"]}},
 "dla_syrpvgrw"=>
  {"summary"=>
    ["DLA_SYRPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "INFO"=>
      ["[in]",
       "         INFO is INTEGER",
       "    The value of INFO returned from DSYTRF, .i.e., the pivot in",
       "    column INFO is exactly 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by DSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by DSYTRF."],
     "WORK"=>
      ["[in]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"]}},
 "cgesc2"=>
  {"summary"=>
    ["CGESC2 solves a system of linear equations",
     "          A * X = scale* RHS",
     "with a general N-by-N matrix A using the LU factorization with",
     "complete pivoting computed by CGETC2."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the  LU part of the factorization of the n-by-n",
       "         matrix A computed by CGETC2:  A = P * L * U * Q"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1, N)."],
     "RHS"=>
      ["[in,out]",
       "         RHS is COMPLEX array, dimension N.",
       "         On entry, the right hand side vector b.",
       "         On exit, the solution vector X."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[in]",
       "         JPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "          On exit, SCALE contains the scale factor. SCALE is chosen",
       "          0 <= SCALE <= 1 to prevent owerflow in the solution."]}},
 "chseqr"=>
  {"summary"=>
    ["   CHSEQR computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**H, where T is an upper triangular matrix (the",
     "   Schur form), and Z is the unitary matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input unitary",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the unitary matrix Q:  A = Q*H*Q**H = (QZ)*T*(QZ)**H."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "          = 'E':  compute eigenvalues only;",
       "          = 'S':  compute eigenvalues and the Schur form T."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "          = 'N':  no Schur vectors are computed;",
       "          = 'I':  Z is initialized to the unit matrix and the matrix Z",
       "                  of Schur vectors of H is returned;",
       "          = 'V':  Z must contain an unitary matrix Q on entry, and",
       "                  the product Q*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "          set by a previous call to CGEBAL, and then passed to ZGEHRD",
       "          when the matrix output by CGEBAL is reduced to Hessenberg",
       "          form. Otherwise ILO and IHI should be set to 1 and N",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and JOB = 'S', H contains the upper",
       "          triangular matrix T from the Schur decomposition (the",
       "          Schur form). If INFO = 0 and JOB = 'E', the contents of",
       "          H are unspecified on exit.  (The output value of H when",
       "          INFO.GT.0 is given under the description of INFO below.)",
       "          Unlike earlier versions of CHSEQR, this subroutine may",
       "          explicitly H(i,j) = 0 for i.GT.j and j = 1, 2, ... ILO-1",
       "          or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX array, dimension (N)",
       "          The computed eigenvalues. If JOB = 'S', the eigenvalues are",
       "          stored in the same order as on the diagonal of the Schur",
       "          form returned in H, with W(i) = H(i,i)."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ,N)",
       "          If COMPZ = 'N', Z is not referenced.",
       "          If COMPZ = 'I', on entry Z need not be set and on exit,",
       "          if INFO = 0, Z contains the unitary matrix Z of the Schur",
       "          vectors of H.  If COMPZ = 'V', on entry Z must contain an",
       "          N-by-N matrix Q, which is assumed to be equal to the unit",
       "          matrix except for the submatrix Z(ILO:IHI,ILO:IHI). On exit,",
       "          if INFO = 0, Z contains Q*Z.",
       "          Normally Q is the unitary matrix generated by CUNGHR",
       "          after the call to CGEHRD which formed the Hessenberg matrix",
       "          H. (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if COMPZ = 'I' or",
       "          COMPZ = 'V', then LDZ.GE.MAX(1,N).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (LWORK)",
       "          On exit, if INFO = 0, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient and delivers very good and sometimes",
       "          optimal performance.  However, LWORK as large as 11*N",
       "          may be required for optimal performance.  A workspace",
       "          query is recommended to determine the optimal workspace",
       "          size.",
       "          If LWORK = -1, then CHSEQR does a workspace query.",
       "          In this case, CHSEQR checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .LT. 0:  if INFO = -i, the i-th argument had an illegal",
       "                   value",
       "          .GT. 0:  if INFO = i, CHSEQR failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and JOB = 'E', then on exit, the",
       "               remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and JOB   = 'S', then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is a unitary matrix.  The final",
       "               value of  H is upper Hessenberg and triangular in",
       "               rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and COMPZ = 'V', then on exit",
       "                 (final value of Z)  =  (initial value of Z)*U",
       "               where U is the unitary matrix in (*) (regard-",
       "               less of the value of JOB.)",
       "               If INFO .GT. 0 and COMPZ = 'I', then on exit",
       "                     (final value of Z)  = U",
       "               where U is the unitary matrix in (*) (regard-",
       "               less of the value of JOB.)",
       "               If INFO .GT. 0 and COMPZ = 'N', then Z is not",
       "               accessed."]}},
 "sgbbrd"=>
  {"summary"=>
    ["SGBBRD reduces a real general m-by-n band matrix A to upper",
     "bidiagonal form B by an orthogonal transformation: Q**T * A * P = B.",
     "The routine computes B, and optionally forms Q or P**T, or computes",
     "Q**T*C for a given matrix C."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         Specifies whether or not the matrices Q and P**T are to be",
       "         formed.",
       "         = 'N': do not form Q or P**T;",
       "         = 'Q': form Q only;",
       "         = 'P': form P**T only;",
       "         = 'B': form both."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NCC"=>
      ["[in]",
       "         NCC is INTEGER",
       "         The number of columns of the matrix C.  NCC >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals of the matrix A. KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals of the matrix A. KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the m-by-n band matrix A, stored in rows 1 to",
       "         KL+KU+1. The j-th column of A is stored in the j-th column of",
       "         the array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl).",
       "         On exit, A is overwritten by values generated during the",
       "         reduction."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A. LDAB >= KL+KU+1."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (min(M,N)-1)",
       "         The superdiagonal elements of the bidiagonal matrix B."],
     "Q"=>
      ["[out]",
       "         Q is REAL array, dimension (LDQ,M)",
       "         If VECT = 'Q' or 'B', the m-by-m orthogonal matrix Q.",
       "         If VECT = 'N' or 'P', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= max(1,M) if VECT = 'Q' or 'B'; LDQ >= 1 otherwise."],
     "PT"=>
      ["[out]",
       "         PT is REAL array, dimension (LDPT,N)",
       "         If VECT = 'P' or 'B', the n-by-n orthogonal matrix P'.",
       "         If VECT = 'N' or 'Q', the array PT is not referenced."],
     "LDPT"=>
      ["[in]",
       "         LDPT is INTEGER",
       "         The leading dimension of the array PT.",
       "         LDPT >= max(1,N) if VECT = 'P' or 'B'; LDPT >= 1 otherwise."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,NCC)",
       "         On entry, an m-by-ncc matrix C.",
       "         On exit, C is overwritten by Q**T*C.",
       "         C is not referenced if NCC = 0."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.",
       "         LDC >= max(1,M) if NCC > 0; LDC >= 1 if NCC = 0."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (2*max(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ctrexc"=>
  {"summary"=>
    ["CTREXC reorders the Schur factorization of a complex matrix",
     "A = Q*T*Q**H, so that the diagonal element of T with row index IFST",
     "is moved to row ILST.",
     "The Schur form T is reordered by a unitary similarity transformation",
     "Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by",
     "postmultplying it with Z."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'V':  update the matrix Q of Schur vectors;",
       "         = 'N':  do not update Q."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0.",
       "         If N == 0 arguments ILST and IFST may be any value."],
     "T"=>
      ["[in,out]",
       "         T is COMPLEX array, dimension (LDT,N)",
       "         On entry, the upper triangular matrix T.",
       "         On exit, the reordered upper triangular matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDQ,N)",
       "         On entry, if COMPQ = 'V', the matrix Q of Schur vectors.",
       "         On exit, if COMPQ = 'V', Q has been postmultiplied by the",
       "         unitary transformation matrix Z which reorders T.",
       "         If COMPQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= 1, and if",
       "         COMPQ = 'V', LDQ >= max(1,N)."],
     "IFST"=>["[in]", "         IFST is INTEGER"],
     "ILST"=>
      ["[in]",
       "         ILST is INTEGER",
       "         Specify the reordering of the diagonal elements of T:",
       "         The element with row index IFST is moved to row ILST by a",
       "         sequence of transpositions between adjacent elements.",
       "         1 <= IFST <= N; 1 <= ILST <= N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhetrs"=>
  {"summary"=>
    ["ZHETRS solves a system of linear equations A*X = B with a complex",
     "Hermitian matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by ZHETRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZHETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHETRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slasyf_rook"=>
  {"summary"=>
    ["SLASYF_ROOK computes a partial factorization of a real symmetric",
     "matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal",
     "pivoting method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**T L21**T )  if UPLO = 'L'",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "SLASYF_ROOK is an auxiliary routine called by SSYTRF_ROOK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "W"=>["[out]", "         W is REAL array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "sgeqrfp"=>
  {"summary"=>
    ["SGEQRFP computes a QR factorization of a real M-by-N matrix A:",
     "A = Q * R. The diagonal entries of R are nonnegative."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n). The diagonal entries of R",
       "         are nonnegative; the elements below the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of min(m,n) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chpevd"=>
  {"summary"=>
    ["CHPEVD computes all the eigenvalues and, optionally, eigenvectors of",
     "a complex Hermitian matrix A in packed storage.  If eigenvectors are",
     "desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the required LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be at least N.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least 2*N.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the required sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the required LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK.",
       "         If N <= 1,               LRWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LRWORK must be at least N.",
       "         If JOBZ = 'V' and N > 1, LRWORK must be at least",
       "                   1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the required LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dtpttf"=>
  {"summary"=>
    ["DTPTTF copies a triangular matrix A from standard packed format (TP)",
     "to rectangular full packed format (TF)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF in Normal format is wanted;",
       "         = 'T':  ARF in Conjugate-transpose format is wanted."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "ARF"=>
      ["[out]",
       "         ARF is DOUBLE PRECISION array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgglse"=>
  {"summary"=>
    ["ZGGLSE solves the linear equality-constrained least squares (LSE)",
     "problem:",
     "        minimize || c - A*x ||_2   subject to   B*x = d",
     "where A is an M-by-N matrix, B is a P-by-N matrix, c is a given",
     "M-vector, and d is a given P-vector. It is assumed that",
     "P <= N <= M+P, and",
     "         rank(B) = P and  rank( (A) ) = N.",
     "                              ( (B) )",
     "These conditions ensure that the LSE problem has a unique solution,",
     "which is obtained using a generalized RQ factorization of the",
     "matrices (B, A) given by",
     "   B = (0 R)*Q,   A = Z*T*Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B. N >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B. 0 <= P <= N <= M+P."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, the upper triangle of the subarray B(1:P,N-P+1:N)",
       "         contains the P-by-P upper triangular matrix R."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (M)",
       "         On entry, C contains the right hand side vector for the",
       "         least squares part of the LSE problem.",
       "         On exit, the residual sum of squares for the solution",
       "         is given by the sum of squares of elements N-P+1 to M of",
       "         vector C."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX*16 array, dimension (P)",
       "         On entry, D contains the right hand side vector for the",
       "         constrained equation.",
       "         On exit, D is destroyed."],
     "X"=>
      ["[out]",
       "         X is COMPLEX*16 array, dimension (N)",
       "         On exit, X is the solution of the LSE problem."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M+N+P).",
       "         For optimum performance LWORK >= P+min(M,N)+max(M,N)*NB,",
       "         where NB is an upper bound for the optimal blocksizes for",
       "         ZGEQRF, CGERQF, ZUNMQR and CUNMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the upper triangular factor R associated with B in the",
       "               generalized RQ factorization of the pair (B, A) is",
       "               singular, so that rank(B) < P; the least squares",
       "               solution could not be computed.",
       "         = 2:  the (N-P) by (N-P) part of the upper trapezoidal factor",
       "               T associated with A in the generalized RQ factorization",
       "               of the pair (B, A) is singular, so that",
       "               rank( (A) ) < N; the least squares solution could not",
       "                   ( (B) )",
       "               be computed."]}},
 "sggbak"=>
  {"summary"=>
    ["SGGBAK forms the right or left eigenvectors of a real generalized",
     "eigenvalue problem A*x = lambda*B*x, by backward transformation on",
     "the computed eigenvectors of the balanced pair of matrices output by",
     "SGGBAL."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the type of backward transformation required:",
       "         = 'N':  do nothing, return immediately;",
       "         = 'P':  do backward transformation for permutation only;",
       "         = 'S':  do backward transformation for scaling only;",
       "         = 'B':  do backward transformations for both permutation and",
       "                 scaling.",
       "         JOB must be the same as the argument JOB supplied to SGGBAL."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  V contains right eigenvectors;",
       "         = 'L':  V contains left eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrix V.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         The integers ILO and IHI determined by SGGBAL.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "LSCALE"=>
      ["[in]",
       "         LSCALE is REAL array, dimension (N)",
       "         Details of the permutations and/or scaling factors applied",
       "         to the left side of A and B, as returned by SGGBAL."],
     "RSCALE"=>
      ["[in]",
       "         RSCALE is REAL array, dimension (N)",
       "         Details of the permutations and/or scaling factors applied",
       "         to the right side of A and B, as returned by SGGBAL."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix V.  M >= 0."],
     "V"=>
      ["[in,out]",
       "         V is REAL array, dimension (LDV,M)",
       "         On entry, the matrix of right or left eigenvectors to be",
       "         transformed, as returned by STGEVC.",
       "         On exit, V is overwritten by the transformed eigenvectors."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the matrix V. LDV >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zptsvx"=>
  {"summary"=>
    ["ZPTSVX uses the factorization A = L*D*L**H to compute the solution",
     "to a complex system of linear equations A*X = B, where A is an",
     "N-by-N Hermitian positive definite tridiagonal matrix and X and B",
     "are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "sgbtrf"=>
  {"summary"=>
    ["SGBTRF computes an LU factorization of a real m-by-n band matrix A",
     "using partial pivoting with row interchanges.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(kl+ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = +i, U(i,i) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "zgttrs"=>
  {"summary"=>
    ["ZGTTRS solves one of the systems of equations",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B,",
     "with a tridiagonal matrix A using the LU factorization computed",
     "by ZGTTRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations.",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A."],
     "D"=>
      ["[in]",
       "         D is COMPLEX*16 array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) elements of the first super-diagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is COMPLEX*16 array, dimension (N-2)",
       "         The (n-2) elements of the second super-diagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the matrix of right hand side vectors B.",
       "         On exit, B is overwritten by the solution vectors X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "dorgqr"=>
  {"summary"=>
    ["DORGQR generates an M-by-N real matrix Q with orthonormal columns,",
     "which is defined as the first N columns of a product of K elementary",
     "reflectors of order M",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by DGEQRF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the i-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by DGEQRF in the first k columns of its array",
       "         argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGEQRF."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "dsytrd"=>
  {"summary"=>
    ["DSYTRD reduces a real symmetric matrix A to real symmetric",
     "tridiagonal form T by an orthogonal similarity transformation:",
     "Q**T * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the orthogonal",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the orthogonal matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= 1.",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cunbdb4"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M and",
       "          M-Q <= min(P,M-P,Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is REAL array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is COMPLEX array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is COMPLEX array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is COMPLEX array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "PHANTOM"=>
      ["[out]",
       "         PHANTOM is COMPLEX array, dimension (M)",
       "          The routine computes an M-by-1 column vector Y that is",
       "          orthogonal to the columns of [ X11; X21 ]. PHANTOM(1:P) and",
       "          PHANTOM(P+1:M) contain Householder vectors for Y(1:P) and",
       "          Y(P+1:M), respectively."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zung2l"=>
  {"summary"=>
    ["ZUNG2L generates an m by n complex matrix Q with orthonormal columns,",
     "which is defined as the last n columns of a product of k elementary",
     "reflectors of order m",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by ZGEQLF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the (n-k+i)-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by ZGEQLF in the last k columns of its array",
       "         argument A.",
       "         On exit, the m-by-n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGEQLF."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "zpotrf"=>
  {"summary"=>
    ["ZPOTRF computes the Cholesky factorization of a complex Hermitian",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the block version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**H *U or A = L*L**H."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "dlauum"=>
  {"summary"=>
    ["DLAUUM computes the product U * U**T or L**T * L, where the triangular",
     "factor U or L is stored in the upper or lower triangular part of",
     "the array A.",
     "If UPLO = 'U' or 'u' then the upper triangle of the result is stored,",
     "overwriting the factor U in A.",
     "If UPLO = 'L' or 'l' then the lower triangle of the result is stored,",
     "overwriting the factor L in A.",
     "This is the blocked form of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the triangular factor stored in the array A",
       "         is upper or lower triangular:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the triangular factor U or L.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L.",
       "         On exit, if UPLO = 'U', the upper triangle of A is",
       "         overwritten with the upper triangle of the product U * U**T;",
       "         if UPLO = 'L', the lower triangle of A is overwritten with",
       "         the lower triangle of the product L**T * L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "ctrsna"=>
  {"summary"=>
    ["CTRSNA estimates reciprocal condition numbers for specified",
     "eigenvalues and/or right eigenvectors of a complex upper triangular",
     "matrix T (or of any matrix Q*T*Q**H with Q unitary)."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for",
       "         eigenvalues (S) or eigenvectors (SEP):",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for eigenvectors only (SEP);",
       "         = 'B': for both eigenvalues and eigenvectors (S and SEP)."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute condition numbers for all eigenpairs;",
       "         = 'S': compute condition numbers for selected eigenpairs",
       "                specified by the array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenpairs for which",
       "         condition numbers are required. To select condition numbers",
       "         for the j-th eigenpair, SELECT(j) must be set to .TRUE..",
       "         If HOWMNY = 'A', SELECT is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension (LDT,N)",
       "         The upper triangular matrix T."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is COMPLEX array, dimension (LDVL,M)",
       "         If JOB = 'E' or 'B', VL must contain left eigenvectors of T",
       "         (or of any Q*T*Q**H with Q unitary), corresponding to the",
       "         eigenpairs specified by HOWMNY and SELECT. The eigenvectors",
       "         must be stored in consecutive columns of VL, as returned by",
       "         CHSEIN or CTREVC.",
       "         If JOB = 'V', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= 1; and if JOB = 'E' or 'B', LDVL >= N."],
     "VR"=>
      ["[in]",
       "         VR is COMPLEX array, dimension (LDVR,M)",
       "         If JOB = 'E' or 'B', VR must contain right eigenvectors of T",
       "         (or of any Q*T*Q**H with Q unitary), corresponding to the",
       "         eigenpairs specified by HOWMNY and SELECT. The eigenvectors",
       "         must be stored in consecutive columns of VR, as returned by",
       "         CHSEIN or CTREVC.",
       "         If JOB = 'V', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= 1; and if JOB = 'E' or 'B', LDVR >= N."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (MM)",
       "         If JOB = 'E' or 'B', the reciprocal condition numbers of the",
       "         selected eigenvalues, stored in consecutive elements of the",
       "         array. Thus S(j), SEP(j), and the j-th columns of VL and VR",
       "         all correspond to the same eigenpair (but not in general the",
       "         j-th eigenpair, unless all eigenpairs are selected).",
       "         If JOB = 'V', S is not referenced."],
     "SEP"=>
      ["[out]",
       "         SEP is REAL array, dimension (MM)",
       "         If JOB = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the selected eigenvectors, stored in consecutive",
       "         elements of the array.",
       "         If JOB = 'E', SEP is not referenced."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of elements in the arrays S (if JOB = 'E' or 'B')",
       "          and/or SEP (if JOB = 'V' or 'B'). MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of elements of the arrays S and/or SEP actually",
       "         used to store the estimated condition numbers.",
       "         If HOWMNY = 'A', M is set to N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (LDWORK,N+6)",
       "         If JOB = 'E', WORK is not referenced."],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         LDWORK >= 1; and if JOB = 'V' or 'B', LDWORK >= N."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (N)",
       "         If JOB = 'E', RWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "cgelsy"=>
  {"summary"=>
    ["CGELSY computes the minimum-norm solution to a complex linear least",
     "squares problem:",
     "    minimize || A * X - B ||",
     "using a complete orthogonal factorization of A.  A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X.",
     "The routine first computes a QR factorization with column pivoting:",
     "    A * P = Q * [ R11 R12 ]",
     "                [  0  R22 ]",
     "with R11 defined as the largest leading submatrix whose estimated",
     "condition number is less than 1/RCOND.  The order of R11, RANK,",
     "is the effective rank of A.",
     "Then, R22 is considered to be negligible, and R12 is annihilated",
     "by unitary transformations from the right, arriving at the",
     "complete orthogonal factorization:",
     "   A * P = Q * [ T11 0 ] * Z",
     "               [  0  0 ]",
     "The minimum-norm solution is then",
     "   X = P * Z**H [ inv(T11)*Q1**H*B ]",
     "                [        0         ]",
     "where Q1 consists of the first RANK columns of Q.",
     "This routine is basically identical to the original xGELSX except",
     "three differences:",
     "  o The permutation of matrix B (the right hand side) is faster and",
     "    more simple.",
     "  o The call to the subroutine xGEQPF has been substituted by the",
     "    the call to the subroutine xGEQP3. This subroutine is a Blas-3",
     "    version of the QR factorization with column pivoting.",
     "  o Matrix B (the right hand side) is updated with Blas-3."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A has been overwritten by details of its",
       "         complete orthogonal factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,M,N)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(i) .ne. 0, the i-th column of A is permuted",
       "         to the front of AP, otherwise column i is a free column.",
       "         On exit, if JPVT(i) = k, then the i-th column of A*P",
       "         was the k-th column of A."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "         RCOND is used to determine the effective rank of A, which",
       "         is defined as the order of the largest leading triangular",
       "         submatrix R11 in the QR factorization with pivoting of A,",
       "         whose estimated condition number < 1/RCOND."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the order of the submatrix",
       "         R11.  This is the same as the order of the submatrix T11",
       "         in the complete orthogonal factorization of A."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         The unblocked strategy requires that:",
       "           LWORK >= MN + MAX( 2*MN, N+1, MN+NRHS )",
       "         where MN = min(M,N).",
       "         The block algorithm requires that:",
       "           LWORK >= MN + MAX( 2*MN, NB*(N+1), MN+MN*NB, MN+NB*NRHS )",
       "         where NB is an upper bound on the blocksize returned",
       "         by ILAENV for the routines CGEQP3, CTZRZF, CTZRQF, CUNMQR,",
       "         and CUNMRZ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "chetf2"=>
  {"summary"=>
    ["CHETF2 computes the factorization of a complex Hermitian matrix A",
     "using the Bunch-Kaufman diagonal pivoting method:",
     "   A = U*D*U**H  or  A = L*D*L**H",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**H is the conjugate transpose of U, and D is",
     "Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "stptri"=>
  {"summary"=>
    ["STPTRI computes the inverse of a real upper or lower triangular",
     "matrix A stored in packed format."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangular matrix A, stored",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*((2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same packed storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, A(i,i) is exactly zero.  The triangular",
       "               matrix is singular and its inverse can not be computed."]}},
 "zgeqrt3"=>
  {"summary"=>
    ["ZGEQRT3 recursively computes a QR factorization of a complex M-by-N",
     "matrix A, using the compact WY representation of Q.",
     "Based on the algorithm of Elmroth and Gustavson,",
     "IBM J. Res. Develop. Vol 44 No. 4 July 2000."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the complex M-by-N matrix A.  On exit, the elements on",
       "         and above the diagonal contain the N-by-N upper triangular matrix R;",
       "         the elements below the diagonal are the columns of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zgesvdx"=>
  {"summary"=>
    [" ZGESVDX computes the singular value decomposition (SVD) of a complex",
     " M-by-N matrix A, optionally computing the left and/or right singular",
     " vectors. The SVD is written",
     "     A = U * SIGMA * transpose(V)",
     " where SIGMA is an M-by-N matrix which is zero except for its",
     " min(m,n) diagonal elements, U is an M-by-M unitary matrix, and",
     " V is an N-by-N unitary matrix.  The diagonal elements of SIGMA",
     " are the singular values of A; they are real and non-negative, and",
     " are returned in descending order.  The first min(m,n) columns of",
     " U and V are the left and right singular vectors of A.",
     " ZGESVDX uses an eigenvalue problem for obtaining the SVD, which",
     " allows for the computation of a subset of singular values and",
     " vectors. See DBDSVDX for details.",
     " Note that the routine returns V**T, not V."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'V':  the first min(m,n) columns of U (the left singular",
       "                 vectors) or as specified by RANGE are returned in",
       "                 the array U;",
       "         = 'N':  no columns of U (no left singular vectors) are",
       "                 computed."],
     "JOBVT"=>
      ["[in]",
       "         JOBVT is CHARACTER*1",
       "          Specifies options for computing all or part of the matrix",
       "          V**T:",
       "          = 'V':  the first min(m,n) rows of V**T (the right singular",
       "                  vectors) or as specified by RANGE are returned in",
       "                  the array VT;",
       "          = 'N':  no rows of V**T (no right singular vectors) are",
       "                  computed."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all singular values will be found.",
       "         = 'V': all singular values in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th singular values will be found."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the contents of A are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "NS"=>
      ["[out]",
       "         NS is INTEGER",
       "         The total number of singular values found,",
       "         0 <= NS <= min(M,N).",
       "         If RANGE = 'A', NS = min(M,N); if RANGE = 'I', NS = IU-IL+1."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is COMPLEX*16 array, dimension (LDU,UCOL)",
       "         If JOBU = 'V', U contains columns of U (the left singular",
       "         vectors, stored columnwise) as specified by RANGE; if",
       "         JOBU = 'N', U is not referenced.",
       "         Note: The user must ensure that UCOL >= NS; if RANGE = 'V',",
       "         the exact value of NS is not known in advance and an upper",
       "         bound must be used."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1; if",
       "         JOBU = 'V', LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is COMPLEX*16 array, dimension (LDVT,N)",
       "         If JOBVT = 'V', VT contains the rows of V**T (the right singular",
       "         vectors, stored rowwise) as specified by RANGE; if JOBVT = 'N',",
       "         VT is not referenced.",
       "         Note: The user must ensure that LDVT >= NS; if RANGE = 'V',",
       "         the exact value of NS is not known in advance and an upper",
       "         bound must be used."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1; if",
       "         JOBVT = 'V', LDVT >= NS (see above)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK;"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= MAX(1,MIN(M,N)*(MIN(M,N)+4)) for the paths (see",
       "         comments inside the code):",
       "            - PATH 1  (M much larger than N)",
       "            - PATH 1t (N much larger than M)",
       "         LWORK >= MAX(1,MIN(M,N)*2+MAX(M,N)) for the other paths.",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))",
       "         LRWORK >= MIN(M,N)*(MIN(M,N)*2+15*MIN(M,N))."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (12*MIN(M,N))",
       "         If INFO = 0, the first NS elements of IWORK are zero. If INFO > 0,",
       "         then IWORK contains the indices of the eigenvectors that failed",
       "         to converge in DBDSVDX/DSTEVX."],
     "INFO"=>
      ["[out]",
       "    INFO is INTEGER",
       "          = 0:  successful exit",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value",
       "          > 0:  if INFO = i, then i eigenvectors failed to converge",
       "                in DBDSVDX/DSTEVX.",
       "                if INFO = N*2 + 1, an internal error occurred in",
       "                DBDSVDX"]}},
 "dgbcon"=>
  {"summary"=>
    ["DGBCON estimates the reciprocal of the condition number of a real",
     "general band matrix A, in either the 1-norm or the infinity-norm,",
     "using the LU factorization computed by DGBTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by DGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= N, row i of the matrix was",
       "         interchanged with row IPIV(i)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zhpevx"=>
  {"summary"=>
    ["ZHPEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian matrix A in packed storage.",
     "Eigenvalues/vectors can be selected by specifying either a range of",
     "values or a range of indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AP to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the selected eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and",
       "         the index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "slasyf"=>
  {"summary"=>
    ["SLASYF computes a partial factorization of a real symmetric matrix A",
     "using the Bunch-Kaufman diagonal pivoting method. The partial",
     "factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**T L21**T )  if UPLO = 'L'",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "SLASYF is an auxiliary routine called by SSYTRF. It uses blocked code",
     "(calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or",
     "A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "W"=>["[out]", "         W is REAL array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "dtrrfs"=>
  {"summary"=>
    ["DTRRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular",
     "coefficient matrix.",
     "The solution matrix X must be computed by DTRTRS or some other",
     "means before entering this routine.  DTRRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ctrtri"=>
  {"summary"=>
    ["CTRTRI computes the inverse of a complex upper or lower triangular",
     "matrix A.",
     "This is the Level 3 BLAS version of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced.  If DIAG = 'U', the",
       "         diagonal elements of A are also not referenced and are",
       "         assumed to be 1.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, A(i,i) is exactly zero.  The triangular",
       "              matrix is singular and its inverse can not be computed."]}},
 "zlarzt"=>
  {"summary"=>
    ["ZLARZT forms the triangular factor T of a complex block reflector",
     "H of order > n, which is defined as a product of k elementary",
     "reflectors.",
     "If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;",
     "If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.",
     "If STOREV = 'C', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th column of the array V, and",
     "   H  =  I - V * T * V**H",
     "If STOREV = 'R', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th row of the array V, and",
     "   H  =  I - V**H * T * V",
     "Currently, only STOREV = 'R' and DIRECT = 'B' are supported."],
   "param"=>
    {"DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies the order in which the elementary reflectors are",
       "         multiplied to form the block reflector:",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Specifies how the vectors which define the elementary",
       "         reflectors are stored (see also Further Details):",
       "         = 'C': columnwise                        (not supported yet)",
       "         = 'R': rowwise"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the block reflector H. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the triangular factor T (= the number of",
       "         elementary reflectors). K >= 1."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX*16 array, dimension",
       "                              (LDV,K) if STOREV = 'C'",
       "                              (LDV,N) if STOREV = 'R'",
       "         The matrix V. See further details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,K)",
       "         The k by k triangular factor T of the block reflector.",
       "         If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is",
       "         lower triangular. The rest of the array is not used."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."]}},
 "csytri2"=>
  {"summary"=>
    ["CSYTRI2 computes the inverse of a COMPLEX symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "CSYTRF. CSYTRI2 sets the LEADING DIMENSION of the workspace",
     "before calling CSYTRI2X that actually computes the inverse."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NB structure of D",
       "         as determined by CSYTRF."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX array, dimension (N+NB+1)*(NB+3)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         WORK is size >= (N+NB+1)*(NB+3)",
       "         If LDWORK = -1, then a workspace query is assumed; the routine",
       "          calculates:",
       "             - the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array,",
       "             - and no error message related to LDWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "zgbbrd"=>
  {"summary"=>
    ["ZGBBRD reduces a complex general m-by-n band matrix A to real upper",
     "bidiagonal form B by a unitary transformation: Q**H * A * P = B.",
     "The routine computes B, and optionally forms Q or P**H, or computes",
     "Q**H*C for a given matrix C."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         Specifies whether or not the matrices Q and P**H are to be",
       "         formed.",
       "         = 'N': do not form Q or P**H;",
       "         = 'Q': form Q only;",
       "         = 'P': form P**H only;",
       "         = 'B': form both."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NCC"=>
      ["[in]",
       "         NCC is INTEGER",
       "         The number of columns of the matrix C.  NCC >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals of the matrix A. KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals of the matrix A. KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the m-by-n band matrix A, stored in rows 1 to",
       "         KL+KU+1. The j-th column of A is stored in the j-th column of",
       "         the array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl).",
       "         On exit, A is overwritten by values generated during the",
       "         reduction."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A. LDAB >= KL+KU+1."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (min(M,N)-1)",
       "         The superdiagonal elements of the bidiagonal matrix B."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,M)",
       "         If VECT = 'Q' or 'B', the m-by-m unitary matrix Q.",
       "         If VECT = 'N' or 'P', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= max(1,M) if VECT = 'Q' or 'B'; LDQ >= 1 otherwise."],
     "PT"=>
      ["[out]",
       "         PT is COMPLEX*16 array, dimension (LDPT,N)",
       "         If VECT = 'P' or 'B', the n-by-n unitary matrix P'.",
       "         If VECT = 'N' or 'Q', the array PT is not referenced."],
     "LDPT"=>
      ["[in]",
       "         LDPT is INTEGER",
       "         The leading dimension of the array PT.",
       "         LDPT >= max(1,N) if VECT = 'P' or 'B'; LDPT >= 1 otherwise."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,NCC)",
       "         On entry, an m-by-ncc matrix C.",
       "         On exit, C is overwritten by Q**H*C.",
       "         C is not referenced if NCC = 0."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.",
       "         LDC >= max(1,M) if NCC > 0; LDC >= 1 if NCC = 0."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX*16 array, dimension (max(M,N))"],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (max(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zhbevx_2stage"=>
  {"summary"=>
    ["ZHBEVX_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian band matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  Eigenvalues and eigenvectors",
     "can be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX*16 array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the N-by-N unitary matrix used in the",
       "                         reduction to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'V', then",
       "         LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AB to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "slasd1"=>
  {"summary"=>
    ["SLASD1 computes the SVD of an upper bidiagonal N-by-M matrix B,",
     "where N = NL + NR + 1 and M = N + SQRE. SLASD1 is called from SLASD0.",
     "A related subroutine SLASD7 handles the case in which the singular",
     "values (and the singular vectors in factored form) are desired.",
     "SLASD1 computes the SVD as follows:",
     "              ( D1(in)    0    0       0 )",
     "  B = U(in) * (   Z1**T   a   Z2**T    b ) * VT(in)",
     "              (   0       0   D2(in)   0 )",
     "    = U(out) * ( D(out) 0) * VT(out)",
     "where Z**T = (Z1**T a Z2**T b) = u**T VT**T, and u is a vector of dimension M",
     "with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros",
     "elsewhere; and the entry b is empty if SQRE = 0.",
     "The left singular vectors of the original matrix are stored in U, and",
     "the transpose of the right singular vectors are stored in VT, and the",
     "singular values are in D.  The algorithm consists of three stages:",
     "   The first stage consists of deflating the size of the problem",
     "   when there are multiple singular values or when there are zeros in",
     "   the Z vector.  For each such occurrence the dimension of the",
     "   secular equation problem is reduced by one.  This stage is",
     "   performed by the routine SLASD2.",
     "   The second stage consists of calculating the updated",
     "   singular values. This is done by finding the square roots of the",
     "   roots of the secular equation via the routine SLASD4 (as called",
     "   by SLASD3). This routine also calculates the singular vectors of",
     "   the current problem.",
     "   The final stage consists of computing the updated singular vectors",
     "   directly using the updated singular values.  The singular vectors",
     "   for the current problem are multiplied with the singular vectors",
     "   from the overall problem."],
   "param"=>
    {"NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block.  NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block.  NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has row dimension N = NL + NR + 1,",
       "        and column dimension M = N + SQRE."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (NL+NR+1).",
       "        N = NL+NR+1",
       "        On entry D(1:NL,1:NL) contains the singular values of the",
       "        upper block; and D(NL+2:N) contains the singular values of",
       "        the lower block. On exit D(1:N) contains the singular values",
       "        of the modified matrix."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is REAL",
       "        Contains the diagonal element associated with the added row."],
     "BETA"=>
      ["[in,out]",
       "         BETA is REAL",
       "        Contains the off-diagonal element associated with the added",
       "        row."],
     "U"=>
      ["[in,out]",
       "         U is REAL array, dimension (LDU,N)",
       "        On entry U(1:NL, 1:NL) contains the left singular vectors of",
       "        the upper block; U(NL+2:N, NL+2:N) contains the left singular",
       "        vectors of the lower block. On exit U contains the left",
       "        singular vectors of the bidiagonal matrix."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "        The leading dimension of the array U.  LDU >= max( 1, N )."],
     "VT"=>
      ["[in,out]",
       "         VT is REAL array, dimension (LDVT,M)",
       "        where M = N + SQRE.",
       "        On entry VT(1:NL+1, 1:NL+1)**T contains the right singular",
       "        vectors of the upper block; VT(NL+2:M, NL+2:M)**T contains",
       "        the right singular vectors of the lower block. On exit",
       "        VT**T contains the right singular vectors of the",
       "        bidiagonal matrix."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "        The leading dimension of the array VT.  LDVT >= max( 1, M )."],
     "IDXQ"=>
      ["[in,out]",
       "         IDXQ is INTEGER array, dimension (N)",
       "        This contains the permutation which will reintegrate the",
       "        subproblem just solved back into sorted order, i.e.",
       "        D( IDXQ( I = 1, N ) ) will be in ascending order."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (4*N)"],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*M**2+2*M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, a singular value did not converge"]}},
 "ssyrfsx"=>
  {"summary"=>
    ["   SSYRFSX improves the computed solution to a system of linear",
     "   equations when the coefficient matrix is symmetric indefinite, and",
     "   provides error bounds and backward error estimates for the",
     "   solution.  In addition to normwise error bound, the code provides",
     "   maximum componentwise error bound if possible.  See comments for",
     "   ERR_BNDS_NORM and ERR_BNDS_COMP for details of the error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED and S",
     "   below. In this case, the solution and error bounds returned are",
     "   for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'Y':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(S) * A * diag(S).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "    upper triangular part of A contains the upper triangular",
       "    part of the matrix A, and the strictly lower triangular",
       "    part of A is not referenced.  If UPLO = 'L', the leading",
       "    N-by-N lower triangular part of A contains the lower",
       "    triangular part of the matrix A, and the strictly upper",
       "    triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The factored form of the matrix A.  AF contains the block",
       "    diagonal matrix D and the multipliers used to obtain the",
       "    factor U or L from the factorization A = U*D*U**T or A =",
       "    L*D*L**T as computed by SSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by SSYTRF."],
     "S"=>
      ["[in,out]",
       "         S is REAL array, dimension (N)",
       "    The scale factors for A.  If EQUED = 'Y', A is multiplied on",
       "    the left and right by diag(S).  S is an input argument if FACT =",
       "    'F'; otherwise, S is an output argument.  If FACT = 'F' and EQUED",
       "    = 'Y', each element of S must be positive.  If S is output, each",
       "    element of S is a power of the radix. If S is input, each element",
       "    of S should be a power of the radix to ensure a reliable solution",
       "    and error estimates. Scaling by powers of the radix does not cause",
       "    rounding errors unless the result underflows or overflows.",
       "    Rounding errors during scaling lead to refining with a matrix that",
       "    is not equivalent to the input matrix, producing error estimates",
       "    that may not be reliable."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by SGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is REAL array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "zpteqr"=>
  {"summary"=>
    ["ZPTEQR computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric positive definite tridiagonal matrix by first factoring the",
     "matrix using DPTTRF and then calling ZBDSQR to compute the singular",
     "values of the bidiagonal factor.",
     "This routine computes the eigenvalues of the positive definite",
     "tridiagonal matrix to high relative accuracy.  This means that if the",
     "eigenvalues range over many orders of magnitude in size, then the",
     "small eigenvalues and corresponding eigenvectors will be computed",
     "more accurately than, for example, with the standard QR method.",
     "The eigenvectors of a full or band positive definite Hermitian matrix",
     "can also be found if ZHETRD, ZHPTRD, or ZHBTRD has been used to",
     "reduce this matrix to tridiagonal form.  (The reduction to",
     "tridiagonal form, however, may preclude the possibility of obtaining",
     "high relative accuracy in the small eigenvalues of the original",
     "matrix, if these eigenvalues range over many orders of magnitude.)"],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'V':  Compute eigenvectors of original Hermitian",
       "                 matrix also.  Array Z contains the unitary matrix",
       "                 used to reduce the original matrix to tridiagonal",
       "                 form.",
       "         = 'I':  Compute eigenvectors of tridiagonal matrix also."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix.",
       "         On normal exit, D contains the eigenvalues, in descending",
       "         order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the unitary matrix used in the",
       "         reduction to tridiagonal form.",
       "         On exit, if COMPZ = 'V', the orthonormal eigenvectors of the",
       "         original Hermitian matrix;",
       "         if COMPZ = 'I', the orthonormal eigenvectors of the",
       "         tridiagonal matrix.",
       "         If INFO > 0 on exit, Z contains the eigenvectors associated",
       "         with only the stored eigenvalues.",
       "         If  COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         COMPZ = 'V' or 'I', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, and i is:",
       "               <= N  the Cholesky factorization of the matrix could",
       "                     not be performed because the i-th principal minor",
       "                     was not positive definite.",
       "               > N   the SVD algorithm failed to converge;",
       "                     if INFO = N+i, i off-diagonal elements of the",
       "                     bidiagonal factor did not converge to zero."]}},
 "clatrs"=>
  {"summary"=>
    ["CLATRS solves one of the triangular systems",
     "   A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b,",
     "with scaling to prevent overflow.  Here A is an upper or lower",
     "triangular matrix, A**T denotes the transpose of A, A**H denotes the",
     "conjugate transpose of A, x and b are n-element vectors, and s is a",
     "scaling factor, usually less than or equal to 1, chosen so that the",
     "components of x will be less than the overflow threshold.  If the",
     "unscaled problem will not cause overflow, the Level 2 BLAS routine",
     "CTRSV is called. If the matrix A is singular (A(j,j) = 0 for some j),",
     "then s is set to 0 and a non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b     (No transpose)",
       "         = 'T':  Solve A**T * x = s*b  (Transpose)",
       "         = 'C':  Solve A**H * x = s*b  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading n by n",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading n by n lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max (1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is REAL array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "dla_porcond"=>
  {"summary"=>
    ["   DLA_PORCOND Estimates the Skeel condition number of  op(A) * op2(C)",
     "   where op2 is determined by CMODE as follows",
     "   CMODE =  1    op2(C) = C",
     "   CMODE =  0    op2(C) = I",
     "   CMODE = -1    op2(C) = inv(C)",
     "   The Skeel condition number  cond(A) = norminf( |inv(A)||A| )",
     "   is computed by computing scaling factors R such that",
     "   diag(R)*A*op2(C) is row equilibrated and computing the standard",
     "   infinity-norm condition number."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by DPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "CMODE"=>
      ["[in]",
       "         CMODE is INTEGER",
       "    Determines op2(C) in the formula op(A) * op2(C) as follows:",
       "    CMODE =  1    op2(C) = C",
       "    CMODE =  0    op2(C) = I",
       "    CMODE = -1    op2(C) = inv(C)"],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The vector C in the formula op(A) * op2(C)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is DOUBLE PRECISION array, dimension (3*N).",
       "    Workspace."],
     "IWORK"=>
      ["[in]",
       "         IWORK is INTEGER array, dimension (N).",
       "    Workspace."]}},
 "sla_gercond"=>
  {"summary"=>
    ["   SLA_GERCOND estimates the Skeel condition number of op(A) * op2(C)",
     "   where op2 is determined by CMODE as follows",
     "   CMODE =  1    op2(C) = C",
     "   CMODE =  0    op2(C) = I",
     "   CMODE = -1    op2(C) = inv(C)",
     "   The Skeel condition number cond(A) = norminf( |inv(A)||A| )",
     "   is computed by computing scaling factors R such that",
     "   diag(R)*A*op2(C) is row equilibrated and computing the standard",
     "   infinity-norm condition number."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by SGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by SGETRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "CMODE"=>
      ["[in]",
       "         CMODE is INTEGER",
       "    Determines op2(C) in the formula op(A) * op2(C) as follows:",
       "    CMODE =  1    op2(C) = C",
       "    CMODE =  0    op2(C) = I",
       "    CMODE = -1    op2(C) = inv(C)"],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The vector C in the formula op(A) * op2(C)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is REAL array, dimension (3*N).",
       "    Workspace."],
     "IWORK"=>
      ["[in]",
       "         IWORK is INTEGER array, dimension (N).",
       "    Workspace.2"]}},
 "claqr1"=>
  {"summary"=>
    ["     Given a 2-by-2 or 3-by-3 matrix H, CLAQR1 sets v to a",
     "     scalar multiple of the first column of the product",
     "     (*)  K = (H - s1*I)*(H - s2*I)",
     "     scaling to avoid overflows and most underflows.",
     "     This is useful for starting double implicit shift bulges",
     "     in the QR algorithm."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is integer",
       "             Order of the matrix H. N must be either 2 or 3."],
     "H"=>
      ["[in]",
       "         H is COMPLEX array of dimension (LDH,N)",
       "             The 2-by-2 or 3-by-3 matrix H in (*)."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "             The leading dimension of H as declared in",
       "             the calling procedure.  LDH.GE.N"],
     "S1"=>["[in]", "         S1 is COMPLEX"],
     "S2"=>
      ["[in]",
       "         S2 is COMPLEX",
       "         S1 and S2 are the shifts defining K in (*) above."],
     "V"=>
      ["[out]",
       "         V is COMPLEX array of dimension N",
       "             A scalar multiple of the first column of the",
       "             matrix K in (*)."]}},
 "ctgex2"=>
  {"summary"=>
    ["CTGEX2 swaps adjacent diagonal 1 by 1 blocks (A11,B11) and (A22,B22)",
     "in an upper triangular matrix pair (A, B) by an unitary equivalence",
     "transformation.",
     "(A, B) must be in generalized Schur canonical form, that is, A and",
     "B are both upper triangular.",
     "Optionally, the matrices Q and Z of generalized Schur vectors are",
     "updated.",
     "       Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H",
     "       Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H"],
   "param"=>
    {"WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX arrays, dimensions (LDA,N)",
       "         On entry, the matrix A in the pair (A, B).",
       "         On exit, the updated matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX arrays, dimensions (LDB,N)",
       "         On entry, the matrix B in the pair (A, B).",
       "         On exit, the updated matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDZ,N)",
       "         If WANTQ = .TRUE, on entry, the unitary matrix Q. On exit,",
       "         the updated matrix Q.",
       "         Not referenced if WANTQ = .FALSE.."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= 1;",
       "         If WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ,N)",
       "         If WANTZ = .TRUE, on entry, the unitary matrix Z. On exit,",
       "         the updated matrix Z.",
       "         Not referenced if WANTZ = .FALSE.."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1;",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The index to the first block (A11, B11)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          =0:  Successful exit.",
       "          =1:  The transformed matrix pair (A, B) would be too far",
       "               from generalized Schur form; the problem is ill-",
       "               conditioned."]}},
 "zuncsd"=>
  {"summary"=>
    ["ZUNCSD computes the CS decomposition of an M-by-M partitioned",
     "unitary matrix X:",
     "                                [  I  0  0 |  0  0  0 ]",
     "                                [  0  C  0 |  0 -S  0 ]",
     "    [ X11 | X12 ]   [ U1 |    ] [  0  0  0 |  0  0 -I ] [ V1 |    ]**H",
     "X = [-----------] = [---------] [---------------------] [---------]   .",
     "    [ X21 | X22 ]   [    | U2 ] [  0  0  0 |  I  0  0 ] [    | V2 ]",
     "                                [  0  S  0 |  0  C  0 ]",
     "                                [  0  0  I |  0  0  0 ]",
     "X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P,",
     "(M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are",
     "R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in",
     "which R = MIN(P,M-P,Q,M-Q)."],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is computed;",
       "         otherwise:  U1 is not computed."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is computed;",
       "         otherwise:  U2 is not computed."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is computed;",
       "         otherwise:  V1T is not computed."],
     "JOBV2T"=>
      ["[in]",
       "         JOBV2T is CHARACTER",
       "         = 'Y':      V2T is computed;",
       "         otherwise:  V2T is not computed."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "SIGNS"=>
      ["[in]",
       "         SIGNS is CHARACTER",
       "         = 'O':      The lower-left block is made nonpositive (the",
       "                     \"other\" convention);",
       "         otherwise:  The upper-right block is made nonpositive (the",
       "                     \"default\" convention)."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11 and X12. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX*16 array, dimension (LDX11,Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. LDX11 >= MAX(1,P)."],
     "X12"=>
      ["[in,out]",
       "         X12 is COMPLEX*16 array, dimension (LDX12,M-Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX12"=>
      ["[in]",
       "         LDX12 is INTEGER",
       "         The leading dimension of X12. LDX12 >= MAX(1,P)."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX*16 array, dimension (LDX21,Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "         The leading dimension of X11. LDX21 >= MAX(1,M-P)."],
     "X22"=>
      ["[in,out]",
       "         X22 is COMPLEX*16 array, dimension (LDX22,M-Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX22"=>
      ["[in]",
       "         LDX22 is INTEGER",
       "         The leading dimension of X11. LDX22 >= MAX(1,M-P)."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (R), in which R =",
       "         MIN(P,M-P,Q,M-Q).",
       "         C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and",
       "         S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) )."],
     "U1"=>
      ["[out]",
       "         U1 is COMPLEX*16 array, dimension (P)",
       "         If JOBU1 = 'Y', U1 contains the P-by-P unitary matrix U1."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of U1. If JOBU1 = 'Y', LDU1 >=",
       "         MAX(1,P)."],
     "U2"=>
      ["[out]",
       "         U2 is COMPLEX*16 array, dimension (M-P)",
       "         If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) unitary",
       "         matrix U2."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of U2. If JOBU2 = 'Y', LDU2 >=",
       "         MAX(1,M-P)."],
     "V1T"=>
      ["[out]",
       "         V1T is COMPLEX*16 array, dimension (Q)",
       "         If JOBV1T = 'Y', V1T contains the Q-by-Q matrix unitary",
       "         matrix V1**H."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >=",
       "         MAX(1,Q)."],
     "V2T"=>
      ["[out]",
       "         V2T is COMPLEX*16 array, dimension (M-Q)",
       "         If JOBV2T = 'Y', V2T contains the (M-Q)-by-(M-Q) unitary",
       "         matrix V2**H."],
     "LDV2T"=>
      ["[in]",
       "         LDV2T is INTEGER",
       "         The leading dimension of V2T. If JOBV2T = 'Y', LDV2T >=",
       "         MAX(1,M-Q)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension MAX(1,LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.",
       "         If INFO > 0 on exit, RWORK(2:R) contains the values PHI(1),",
       "         ..., PHI(R-1) that, together with THETA(1), ..., THETA(R),",
       "         define the matrix in intermediate bidiagonal-block form",
       "         remaining after nonconvergence. INFO specifies the number",
       "         of nonzero PHI's."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If LRWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the RWORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LRWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  ZBBCSD did not converge. See the description of RWORK",
       "               above for details."]}},
 "zherfsx"=>
  {"summary"=>
    ["   ZHERFSX improves the computed solution to a system of linear",
     "   equations when the coefficient matrix is Hermitian indefinite, and",
     "   provides error bounds and backward error estimates for the",
     "   solution.  In addition to normwise error bound, the code provides",
     "   maximum componentwise error bound if possible.  See comments for",
     "   ERR_BNDS_NORM and ERR_BNDS_COMP for details of the error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED and S",
     "   below. In this case, the solution and error bounds returned are",
     "   for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'Y':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(S) * A * diag(S).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "    upper triangular part of A contains the upper triangular",
       "    part of the matrix A, and the strictly lower triangular",
       "    part of A is not referenced.  If UPLO = 'L', the leading",
       "    N-by-N lower triangular part of A contains the lower",
       "    triangular part of the matrix A, and the strictly upper",
       "    triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The factored form of the matrix A.  AF contains the block",
       "    diagonal matrix D and the multipliers used to obtain the",
       "    factor U or L from the factorization A = U*D*U**T or A =",
       "    L*D*L**T as computed by DSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by DSYTRF."],
     "S"=>
      ["[in,out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "    The scale factors for A.  If EQUED = 'Y', A is multiplied on",
       "    the left and right by diag(S).  S is an input argument if FACT =",
       "    'F'; otherwise, S is an output argument.  If FACT = 'F' and EQUED",
       "    = 'Y', each element of S must be positive.  If S is output, each",
       "    element of S is a power of the radix. If S is input, each element",
       "    of S should be a power of the radix to ensure a reliable solution",
       "    and error estimates. Scaling by powers of the radix does not cause",
       "    rounding errors unless the result underflows or overflows.",
       "    Rounding errors during scaling lead to refining with a matrix that",
       "    is not equivalent to the input matrix, producing error estimates",
       "    that may not be reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by DGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is DOUBLE PRECISION array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0D+0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "ctgevc"=>
  {"summary"=>
    ["CTGEVC computes some or all of the right and/or left eigenvectors of",
     "a pair of complex matrices (S,P), where S and P are upper triangular.",
     "Matrix pairs of this type are produced by the generalized Schur",
     "factorization of a complex matrix pair (A,B):",
     "   A = Q*S*Z**H,  B = Q*P*Z**H",
     "as computed by CGGHRD + CHGEQZ.",
     "The right eigenvector x and the left eigenvector y of (S,P)",
     "corresponding to an eigenvalue w are defined by:",
     "   S*x = w*P*x,  (y**H)*S = w*(y**H)*P,",
     "where y**H denotes the conjugate tranpose of y.",
     "The eigenvalues are not input to this routine, but are computed",
     "directly from the diagonal elements of S and P.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of (S,P), or the products Z*X and/or Q*Y,",
     "where Z and Q are input matrices.",
     "If Q and Z are the unitary factors from the generalized Schur",
     "factorization of a matrix pair (A,B), then Z*X and Q*Y",
     "are the matrices of right and left eigenvectors of (A,B)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R': compute right eigenvectors only;",
       "         = 'L': compute left eigenvectors only;",
       "         = 'B': compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute all right and/or left eigenvectors;",
       "         = 'B': compute all right and/or left eigenvectors,",
       "                backtransformed by the matrices in VR and/or VL;",
       "         = 'S': compute selected right and/or left eigenvectors,",
       "                specified by the logical array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY='S', SELECT specifies the eigenvectors to be",
       "         computed.  The eigenvector corresponding to the j-th",
       "         eigenvalue is computed if SELECT(j) = .TRUE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices S and P.  N >= 0."],
     "S"=>
      ["[in]",
       "         S is COMPLEX array, dimension (LDS,N)",
       "         The upper triangular matrix S from a generalized Schur",
       "         factorization, as computed by CHGEQZ."],
     "LDS"=>
      ["[in]",
       "         LDS is INTEGER",
       "         The leading dimension of array S.  LDS >= max(1,N)."],
     "P"=>
      ["[in]",
       "         P is COMPLEX array, dimension (LDP,N)",
       "         The upper triangular matrix P from a generalized Schur",
       "         factorization, as computed by CHGEQZ.  P must have real",
       "         diagonal elements."],
     "LDP"=>
      ["[in]",
       "         LDP is INTEGER",
       "         The leading dimension of array P.  LDP >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is COMPLEX array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Q",
       "         of left Schur vectors returned by CHGEQZ).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of (S,P);",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of (S,P) specified by",
       "                     SELECT, stored consecutively in the columns of",
       "                     VL, in the same order as their eigenvalues.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of array VL.  LDVL >= 1, and if",
       "         SIDE = 'L' or 'l' or 'B' or 'b', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is COMPLEX array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Z",
       "         of right Schur vectors returned by CHGEQZ).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of (S,P);",
       "         if HOWMNY = 'B', the matrix Z*X;",
       "         if HOWMNY = 'S', the right eigenvectors of (S,P) specified by",
       "                     SELECT, stored consecutively in the columns of",
       "                     VR, in the same order as their eigenvalues.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1, and if",
       "         SIDE = 'R' or 'B', LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.  If HOWMNY = 'A' or 'B', M",
       "         is set to N.  Each selected eigenvector occupies one column."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "chetrf_rk"=>
  {"summary"=>
    ["CHETRF_RK computes the factorization of a complex Hermitian matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the Hermitian block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension ( MAX(1,LWORK) ).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned",
       "         by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array, returns this value as the first entry of the WORK",
       "         array, and no error message related to LWORK is issued",
       "         by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "cupmtr"=>
  {"summary"=>
    ["CUPMTR overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "nq-1 elementary reflectors, as returned by CHPTRD using packed",
     "storage:",
     "if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangular packed storage used in previous",
       "                call to CHPTRD;",
       "         = 'L': Lower triangular packed storage used in previous",
       "                call to CHPTRD."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension",
       "                              (M*(M+1)/2) if SIDE = 'L'",
       "                              (N*(N+1)/2) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by CHPTRD.  AP is modified by the routine but",
       "         restored on exit."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (M-1) if SIDE = 'L'",
       "                                    or (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CHPTRD."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension",
       "                                  (N) if SIDE = 'L'",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhpevd"=>
  {"summary"=>
    ["ZHPEVD computes all the eigenvalues and, optionally, eigenvectors of",
     "a complex Hermitian matrix A in packed storage.  If eigenvectors are",
     "desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the required LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be at least N.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least 2*N.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the required sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array,",
       "                                        dimension (LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the required LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK.",
       "         If N <= 1,               LRWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LRWORK must be at least N.",
       "         If JOBZ = 'V' and N > 1, LRWORK must be at least",
       "                   1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the required LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "zgesvd"=>
  {"summary"=>
    ["ZGESVD computes the singular value decomposition (SVD) of a complex",
     "M-by-N matrix A, optionally computing the left and/or right singular",
     "vectors. The SVD is written",
     "     A = U * SIGMA * conjugate-transpose(V)",
     "where SIGMA is an M-by-N matrix which is zero except for its",
     "min(m,n) diagonal elements, U is an M-by-M unitary matrix, and",
     "V is an N-by-N unitary matrix.  The diagonal elements of SIGMA",
     "are the singular values of A; they are real and non-negative, and",
     "are returned in descending order.  The first min(m,n) columns of",
     "U and V are the left and right singular vectors of A.",
     "Note that the routine returns V**H, not V."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'A':  all M columns of U are returned in array U:",
       "         = 'S':  the first min(m,n) columns of U (the left singular",
       "                 vectors) are returned in the array U;",
       "         = 'O':  the first min(m,n) columns of U (the left singular",
       "                 vectors) are overwritten on the array A;",
       "         = 'N':  no columns of U (no left singular vectors) are",
       "                 computed."],
     "JOBVT"=>
      ["[in]",
       "         JOBVT is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix",
       "         V**H:",
       "         = 'A':  all N rows of V**H are returned in the array VT;",
       "         = 'S':  the first min(m,n) rows of V**H (the right singular",
       "                 vectors) are returned in the array VT;",
       "         = 'O':  the first min(m,n) rows of V**H (the right singular",
       "                 vectors) are overwritten on the array A;",
       "         = 'N':  no rows of V**H (no right singular vectors) are",
       "                 computed.",
       "         JOBVT and JOBU cannot both be 'O'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if JOBU = 'O',  A is overwritten with the first min(m,n)",
       "                         columns of U (the left singular vectors,",
       "                         stored columnwise);",
       "         if JOBVT = 'O', A is overwritten with the first min(m,n)",
       "                         rows of V**H (the right singular vectors,",
       "                         stored rowwise);",
       "         if JOBU .ne. 'O' and JOBVT .ne. 'O', the contents of A",
       "                         are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is COMPLEX*16 array, dimension (LDU,UCOL)",
       "         (LDU,M) if JOBU = 'A' or (LDU,min(M,N)) if JOBU = 'S'.",
       "         If JOBU = 'A', U contains the M-by-M unitary matrix U;",
       "         if JOBU = 'S', U contains the first min(m,n) columns of U",
       "         (the left singular vectors, stored columnwise);",
       "         if JOBU = 'N' or 'O', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1; if",
       "         JOBU = 'S' or 'A', LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is COMPLEX*16 array, dimension (LDVT,N)",
       "         If JOBVT = 'A', VT contains the N-by-N unitary matrix",
       "         V**H;",
       "         if JOBVT = 'S', VT contains the first min(m,n) rows of",
       "         V**H (the right singular vectors, stored rowwise);",
       "         if JOBVT = 'N' or 'O', VT is not referenced."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1; if",
       "         JOBVT = 'A', LDVT >= N; if JOBVT = 'S', LDVT >= min(M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >=  MAX(1,2*MIN(M,N)+MAX(M,N)).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (5*min(M,N))",
       "         On exit, if INFO > 0, RWORK(1:MIN(M,N)-1) contains the",
       "         unconverged superdiagonal elements of an upper bidiagonal",
       "         matrix B whose diagonal is in S (not necessarily sorted).",
       "         B satisfies A = U * B * VT, so it has the same singular",
       "         values as A, and singular vectors related by U and VT."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if ZBDSQR did not converge, INFO specifies how many",
       "               superdiagonals of an intermediate bidiagonal form B",
       "               did not converge to zero. See the description of RWORK",
       "               above for details."]}},
 "dsyconvf_rook"=>
  {"summary"=>
    ["If parameter WAY = 'C':",
     "DSYCONVF_ROOK converts the factorization output format used in",
     "DSYTRF_ROOK provided on entry in parameter A into the factorization",
     "output format used in DSYTRF_RK (or DSYTRF_BK) that is stored",
     "on exit in parameters A and E. IPIV format for DSYTRF_ROOK and",
     "DSYTRF_RK (or DSYTRF_BK) is the same and is not converted.",
     "If parameter WAY = 'R':",
     "DSYCONVF_ROOK performs the conversion in reverse direction, i.e.",
     "converts the factorization output format used in DSYTRF_RK",
     "(or DSYTRF_BK) provided on entry in parametes A and E into",
     "the factorization output format used in DSYTRF_ROOK that is stored",
     "on exit in parameter A. IPIV format for DSYTRF_ROOK and",
     "DSYTRF_RK (or DSYTRF_BK) is the same and is not converted."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix A.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         1) If WAY ='C':",
       "         On entry, contains factorization details in format used in",
       "         DSYTRF_ROOK:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         DSYTRF_RK or DSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         2) If WAY = 'R':",
       "         On entry, contains factorization details in format used in",
       "         DSYTRF_RK or DSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         DSYTRF_ROOK:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, just a workspace.",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         2) If WAY = 'R':",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not referenced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         On exit, is not changed"],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On entry, details of the interchanges and the block",
       "         structure of D as determined:",
       "         1) by DSYTRF_ROOK, if WAY ='C';",
       "         2) by DSYTRF_RK (or DSYTRF_BK), if WAY ='R'.",
       "         The IPIV format is the same for all these routines.",
       "         On exit, is not changed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sspsv"=>
  {"summary"=>
    ["SSPSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix stored in packed format and X",
     "and B are N-by-NRHS matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, D is symmetric and block diagonal with 1-by-1",
     "and 2-by-2 diagonal blocks.  The factored form of A is then used to",
     "solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L from the factorization",
       "         A = U*D*U**T or A = L*D*L**T as computed by SSPTRF, stored as",
       "         a packed triangular matrix in the same storage format as A."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by SSPTRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, so the solution could not be",
       "               computed."]}},
 "spotrf"=>
  {"summary"=>
    ["SPOTRF computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the block version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "dlaqr5"=>
  {"summary"=>
    ["   DLAQR5, called by DLAQR0, performs a",
     "   single small-bulge multi-shift QR sweep."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is logical scalar",
       "            WANTT = .true. if the quasi-triangular Schur factor",
       "            is being computed.  WANTT is set to .false. otherwise."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is logical scalar",
       "            WANTZ = .true. if the orthogonal Schur factor is being",
       "            computed.  WANTZ is set to .false. otherwise."],
     "KACC22"=>
      ["[in]",
       "         KACC22 is integer with value 0, 1, or 2.",
       "            Specifies the computation mode of far-from-diagonal",
       "            orthogonal updates.",
       "       = 0: DLAQR5 does not accumulate reflections and does not",
       "            use matrix-matrix multiply to update far-from-diagonal",
       "            matrix entries.",
       "       = 1: DLAQR5 accumulates reflections and uses matrix-matrix",
       "            multiply to update the far-from-diagonal matrix entries.",
       "       = 2: DLAQR5 accumulates reflections, uses matrix-matrix",
       "            multiply to update the far-from-diagonal matrix entries,",
       "            and takes advantage of 2-by-2 block structure during",
       "            matrix multiplies."],
     "N"=>
      ["[in]",
       "         N is integer scalar",
       "            N is the order of the Hessenberg matrix H upon which this",
       "            subroutine operates."],
     "KTOP"=>["[in]", "         KTOP is integer scalar"],
     "KBOT"=>
      ["[in]",
       "         KBOT is integer scalar",
       "            These are the first and last rows and columns of an",
       "            isolated diagonal block upon which the QR sweep is to be",
       "            applied. It is assumed without a check that",
       "                      either KTOP = 1  or   H(KTOP,KTOP-1) = 0",
       "            and",
       "                      either KBOT = N  or   H(KBOT+1,KBOT) = 0."],
     "NSHFTS"=>
      ["[in]",
       "         NSHFTS is integer scalar",
       "            NSHFTS gives the number of simultaneous shifts.  NSHFTS",
       "            must be positive and even."],
     "SR"=>
      ["[in,out]", "         SR is DOUBLE PRECISION array of size (NSHFTS)"],
     "SI"=>
      ["[in,out]",
       "         SI is DOUBLE PRECISION array of size (NSHFTS)",
       "            SR contains the real parts and SI contains the imaginary",
       "            parts of the NSHFTS shifts of origin that define the",
       "            multi-shift QR sweep.  On output SR and SI may be",
       "            reordered."],
     "H"=>
      ["[in,out]",
       "         H is DOUBLE PRECISION array of size (LDH,N)",
       "            On input H contains a Hessenberg matrix.  On output a",
       "            multi-shift QR sweep with shifts SR(J)+i*SI(J) is applied",
       "            to the isolated diagonal block in rows and columns KTOP",
       "            through KBOT."],
     "LDH"=>
      ["[in]",
       "         LDH is integer scalar",
       "            LDH is the leading dimension of H just as declared in the",
       "            calling procedure.  LDH.GE.MAX(1,N)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "            Specify the rows of Z to which transformations must be",
       "            applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N"],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array of size (LDZ,IHIZ)",
       "            If WANTZ = .TRUE., then the QR Sweep orthogonal",
       "            similarity transformation is accumulated into",
       "            Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "            If WANTZ = .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer scalar",
       "            LDA is the leading dimension of Z just as declared in",
       "            the calling procedure. LDZ.GE.N."],
     "V"=>
      ["[out]", "         V is DOUBLE PRECISION array of size (LDV,NSHFTS/2)"],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "            LDV is the leading dimension of V as declared in the",
       "            calling procedure.  LDV.GE.3."],
     "U"=>
      ["[out]",
       "         U is DOUBLE PRECISION array of size",
       "            (LDU,3*NSHFTS-3)"],
     "LDU"=>
      ["[in]",
       "         LDU is integer scalar",
       "            LDU is the leading dimension of U just as declared in the",
       "            in the calling subroutine.  LDU.GE.3*NSHFTS-3."],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "            NH is the number of columns in array WH available for",
       "            workspace. NH.GE.1."],
     "WH"=>
      ["[out]", "         WH is DOUBLE PRECISION array of size (LDWH,NH)"],
     "LDWH"=>
      ["[in]",
       "         LDWH is integer scalar",
       "            Leading dimension of WH just as declared in the",
       "            calling procedure.  LDWH.GE.3*NSHFTS-3."],
     "NV"=>
      ["[in]",
       "         NV is integer scalar",
       "            NV is the number of rows in WV agailable for workspace.",
       "            NV.GE.1."],
     "WV"=>
      ["[out]",
       "         WV is DOUBLE PRECISION array of size",
       "            (LDWV,3*NSHFTS-3)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer scalar",
       "            LDWV is the leading dimension of WV as declared in the",
       "            in the calling subroutine.  LDWV.GE.NV."]}},
 "zpbequ"=>
  {"summary"=>
    ["ZPBEQU computes row and column scalings intended to equilibrate a",
     "Hermitian positive definite band matrix A and reduce its condition",
     "number (with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular of A is stored;",
       "         = 'L':  Lower triangular of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The upper or lower triangle of the Hermitian band matrix A,",
       "         stored in the first KD+1 rows of the array.  The j-th column",
       "         of A is stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A.  LDAB >= KD+1."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is DOUBLE PRECISION",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "zlaqgb"=>
  {"summary"=>
    ["ZLAQGB equilibrates a general M by N band matrix A with KL",
     "subdiagonals and KU superdiagonals using the row and scaling factors",
     "in the vectors R and C."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, the equilibrated matrix, in the same storage format",
       "         as A.  See EQUED for the form of the equilibrated matrix."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDA >= KL+KU+1."],
     "R"=>
      ["[in]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         The row scale factors for A."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         The column scale factors for A."],
     "ROWCND"=>
      ["[in]",
       "         ROWCND is DOUBLE PRECISION",
       "         Ratio of the smallest R(i) to the largest R(i)."],
     "COLCND"=>
      ["[in]",
       "         COLCND is DOUBLE PRECISION",
       "         Ratio of the smallest C(i) to the largest C(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies the form of equilibration that was done.",
       "         = 'N':  No equilibration",
       "         = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "                 diag(R).",
       "         = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "                 by diag(C).",
       "         = 'B':  Both row and column equilibration, i.e., A has been",
       "                 replaced by diag(R) * A * diag(C)."]}},
 "sbdsvdx"=>
  {"summary"=>
    [" SBDSVDX computes the singular value decomposition (SVD) of a real",
     " N-by-N (upper or lower) bidiagonal matrix B, B = U * S * VT,",
     " where S is a diagonal matrix with non-negative diagonal elements",
     " (the singular values of B), and U and VT are orthogonal matrices",
     " of left and right singular vectors, respectively.",
     " Given an upper bidiagonal B with diagonal D = [ d_1 d_2 ... d_N ]",
     " and superdiagonal E = [ e_1 e_2 ... e_N-1 ], SBDSVDX computes the",
     " singular value decompositon of B through the eigenvalues and",
     " eigenvectors of the N*2-by-N*2 tridiagonal matrix",
     "       |  0  d_1                |",
     "       | d_1  0  e_1            |",
     " TGK = |     e_1  0  d_2        |",
     "       |         d_2  .   .     |",
     "       |              .   .   . |",
     " If (s,u,v) is a singular triplet of B with ||u|| = ||v|| = 1, then",
     " (+/-s,q), ||q|| = 1, are eigenpairs of TGK, with q = P * ( u' +/-v' ) /",
     " sqrt(2) = ( v_1 u_1 v_2 u_2 ... v_n u_n ) / sqrt(2), and",
     " P = [ e_{n+1} e_{1} e_{n+2} e_{2} ... ].",
     " Given a TGK matrix, one can either a) compute -s,-v and change signs",
     " so that the singular values (and corresponding vectors) are already in",
     " descending order (as in SGESVD/SGESDD) or b) compute s,v and reorder",
     " the values (and corresponding vectors). SBDSVDX implements a) by",
     " calling SSTEVX (bisection plus inverse iteration, to be replaced",
     " with a version of the Multiple Relative Robust Representation",
     " algorithm. (See P. Willems and B. Lang, A framework for the MR^3",
     " algorithm: theory and implementation, SIAM J. Sci. Comput.,",
     " 35:740-766, 2013.)"],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  B is upper bidiagonal;",
       "         = 'L':  B is lower bidiagonal."],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute singular values only;",
       "         = 'V':  Compute singular values and singular vectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all singular values will be found.",
       "         = 'V': all singular values in the half-open interval [VL,VU)",
       "                will be found.",
       "         = 'I': the IL-th through IU-th singular values will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the bidiagonal matrix.  N >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the bidiagonal matrix B."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (max(1,N-1))",
       "         The (n-1) superdiagonal elements of the bidiagonal matrix",
       "         B in elements 1 to N-1."],
     "VL"=>
      ["[in]",
       "        VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "        VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "NS"=>
      ["[out]",
       "         NS is INTEGER",
       "         The total number of singular values found.  0 <= NS <= N.",
       "         If RANGE = 'A', NS = N, and if RANGE = 'I', NS = IU-IL+1."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         The first NS elements contain the selected singular values in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (2*N,K) )",
       "         If JOBZ = 'V', then if INFO = 0 the first NS columns of Z",
       "         contain the singular vectors of the matrix B corresponding to",
       "         the selected singular values, with U in rows 1 to N and V",
       "         in rows N+1 to N*2, i.e.",
       "         Z = [ U ]",
       "             [ V ]",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: The user must ensure that at least K = NS+1 columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of",
       "         NS is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(2,N*2)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (14*N)"],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (12*N)",
       "         If JOBZ = 'V', then if INFO = 0, the first NS elements of",
       "         IWORK are zero. If INFO > 0, then IWORK contains the indices",
       "         of the eigenvectors that failed to converge in DSTEVX."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge",
       "                  in SSTEVX. The indices of the eigenvectors",
       "                  (as returned by SSTEVX) are stored in the",
       "                  array IWORK.",
       "               if INFO = N*2 + 1, an internal error occurred."]}},
 "strtrs"=>
  {"summary"=>
    ["STRTRS solves a triangular system of the form",
     "   A * X = B  or  A**T * X = B,",
     "where A is a triangular matrix of order N, and B is an N-by-NRHS",
     "matrix.  A check is made to verify that A is nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, the i-th diagonal element of A is zero,",
       "              indicating that the matrix is singular and the solutions",
       "              X have not been computed."]}},
 "dla_lin_berr"=>
  {"summary"=>
    ["   DLA_LIN_BERR computes component-wise relative backward error from",
     "   the formula",
     "       max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
     "   where abs(Z) is the component-wise absolute value of the matrix",
     "   or vector Z."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NZ"=>
      ["[in]",
       "         NZ is INTEGER",
       "    We add (NZ+1)*SLAMCH( 'Safe minimum' ) to R(i) in the numerator to",
       "    guard against spuriously zero residuals. Default value is N."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices AYB, RES, and BERR.  NRHS >= 0."],
     "RES"=>
      ["[in]",
       "         RES is DOUBLE PRECISION array, dimension (N,NRHS)",
       "    The residual matrix, i.e., the matrix R in the relative backward",
       "    error formula above."],
     "AYB"=>
      ["[in]",
       "         AYB is DOUBLE PRECISION array, dimension (N, NRHS)",
       "    The denominator in the relative backward error formula above, i.e.,",
       "    the matrix abs(op(A_s))*abs(Y) + abs(B_s). The matrices A, Y, and B",
       "    are from iterative refinement (see dla_gerfsx_extended.f)."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "    The component-wise relative backward error from the formula above."]}},
 "slar2v"=>
  {"summary"=>
    ["SLAR2V applies a vector of real plane rotations from both sides to",
     "a sequence of 2-by-2 real symmetric matrices, defined by the elements",
     "of the vectors x, y and z. For i = 1,2,...,n",
     "   ( x(i)  z(i) ) := (  c(i)  s(i) ) ( x(i)  z(i) ) ( c(i) -s(i) )",
     "   ( z(i)  y(i) )    ( -s(i)  c(i) ) ( z(i)  y(i) ) ( s(i)  c(i) )"],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be applied."],
     "X"=>
      ["[in,out]",
       "         X is REAL array,",
       "                        dimension (1+(N-1)*INCX)",
       "         The vector x."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array,",
       "                        dimension (1+(N-1)*INCX)",
       "         The vector y."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array,",
       "                        dimension (1+(N-1)*INCX)",
       "         The vector z."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X, Y and Z. INCX > 0."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension (1+(N-1)*INCC)",
       "         The sines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C and S. INCC > 0."]}},
 "dorbdb2"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= min(M-P,Q,M-Q)."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is DOUBLE PRECISION array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is DOUBLE PRECISION array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is DOUBLE PRECISION array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is DOUBLE PRECISION array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is DOUBLE PRECISION array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "chegvd"=>
  {"summary"=>
    ["CHEGVD computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be Hermitian and B is also positive definite.",
     "If eigenvectors are desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the Hermitian matrix B.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of B contains the",
       "         upper triangular part of the matrix B.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of B contains",
       "         the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.",
       "         If N <= 1,                LWORK >= 1.",
       "         If JOBZ  = 'N' and N > 1, LWORK >= N + 1.",
       "         If JOBZ  = 'V' and N > 1, LWORK >= 2*N + N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If N <= 1,                LRWORK >= 1.",
       "         If JOBZ  = 'N' and N > 1, LRWORK >= N.",
       "         If JOBZ  = 'V' and N > 1, LRWORK >= 1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK >= 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK >= 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  CPOTRF or CHEEVD returned an error code:",
       "            <= N:  if INFO = i and JOBZ = 'N', then the algorithm",
       "                   failed to converge; i off-diagonal elements of an",
       "                   intermediate tridiagonal form did not converge to",
       "                   zero;",
       "                   if INFO = i and JOBZ = 'V', then the algorithm",
       "                   failed to compute an eigenvalue while working on",
       "                   the submatrix lying in rows and columns INFO/(N+1)",
       "                   through mod(INFO,N+1);",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "zgelqt3"=>
  {"summary"=>
    ["DGELQT3 recursively computes a LQ factorization of a complex M-by-N",
     "matrix A, using the compact WY representation of Q.",
     "Based on the algorithm of Elmroth and Gustavson,",
     "IBM J. Res. Develop. Vol 44 No. 4 July 2000."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M =< N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the real M-by-N matrix A.  On exit, the elements on and",
       "         below the diagonal contain the N-by-N lower triangular matrix L; the",
       "         elements above the diagonal are the rows of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "slags2"=>
  {"summary"=>
    ["SLAGS2 computes 2-by-2 orthogonal matrices U, V and Q, such",
     "that if ( UPPER ) then",
     "          U**T *A*Q = U**T *( A1 A2 )*Q = ( x  0  )",
     "                            ( 0  A3 )     ( x  x  )",
     "and",
     "          V**T*B*Q = V**T *( B1 B2 )*Q = ( x  0  )",
     "                           ( 0  B3 )     ( x  x  )",
     "or if ( .NOT.UPPER ) then",
     "          U**T *A*Q = U**T *( A1 0  )*Q = ( x  x  )",
     "                            ( A2 A3 )     ( 0  x  )",
     "and",
     "          V**T*B*Q = V**T*( B1 0  )*Q = ( x  x  )",
     "                          ( B2 B3 )     ( 0  x  )",
     "The rows of the transformed A and B are parallel, where",
     "  U = (  CSU  SNU ), V = (  CSV SNV ), Q = (  CSQ   SNQ )",
     "      ( -SNU  CSU )      ( -SNV CSV )      ( -SNQ   CSQ )",
     "Z**T denotes the transpose of Z."],
   "param"=>
    {"UPPER"=>
      ["[in]",
       "         UPPER is LOGICAL",
       "         = .TRUE.: the input matrices A and B are upper triangular.",
       "         = .FALSE.: the input matrices A and B are lower triangular."],
     "A1"=>["[in]", "         A1 is REAL"],
     "A2"=>["[in]", "         A2 is REAL"],
     "A3"=>
      ["[in]",
       "         A3 is REAL",
       "         On entry, A1, A2 and A3 are elements of the input 2-by-2",
       "         upper (lower) triangular matrix A."],
     "B1"=>["[in]", "         B1 is REAL"],
     "B2"=>["[in]", "         B2 is REAL"],
     "B3"=>
      ["[in]",
       "         B3 is REAL",
       "         On entry, B1, B2 and B3 are elements of the input 2-by-2",
       "         upper (lower) triangular matrix B."],
     "CSU"=>["[out]", "         CSU is REAL"],
     "SNU"=>
      ["[out]",
       "         SNU is REAL",
       "         The desired orthogonal matrix U."],
     "CSV"=>["[out]", "         CSV is REAL"],
     "SNV"=>
      ["[out]",
       "         SNV is REAL",
       "         The desired orthogonal matrix V."],
     "CSQ"=>["[out]", "         CSQ is REAL"],
     "SNQ"=>
      ["[out]",
       "         SNQ is REAL",
       "         The desired orthogonal matrix Q."]}},
 "zlanhe"=>
  {"summary"=>
    ["ZLANHE  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex hermitian matrix A.",
     "   ZLANHE = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANHE as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         hermitian matrix A is to be referenced.",
       "         = 'U':  Upper triangular part of A is referenced",
       "         = 'L':  Lower triangular part of A is referenced"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANHE is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The hermitian matrix A.  If UPLO = 'U', the leading n by n",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading n by n lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced. Note that the imaginary parts of the diagonal",
       "         elements need not be set and are assumed to be zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "sormr3"=>
  {"summary"=>
    ["SORMR3 overwrites the general real m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**T* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**T if SIDE = 'R' and TRANS = 'C',",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by STZRZF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left",
       "         = 'R': apply Q or Q**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'T': apply Q**T (Transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing",
       "         the meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         STZRZF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by STZRZF."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dsyevx_2stage"=>
  {"summary"=>
    ["DSYEVX_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  Eigenvalues and eigenvectors can be",
     "selected by specifying either a range of values or a range of indices",
     "for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, 8*N, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + 3*N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + 3*N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "ctpqrt2"=>
  {"summary"=>
    ["CTPQRT2 computes a QR factorization of a complex \"triangular-pentagonal\"",
     "matrix C, which is composed of a triangular block A and pentagonal block B,",
     "using the compact WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of",
       "         the triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the upper trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the upper triangular N-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first M-L rows",
       "         are rectangular, and the last L rows are upper trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor T of the block reflector.",
       "         See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "clartv"=>
  {"summary"=>
    ["CLARTV applies a vector of complex plane rotations with real cosines",
     "to elements of the complex vectors x and y. For i = 1,2,...,n",
     "   ( x(i) ) := (        c(i)   s(i) ) ( x(i) )",
     "   ( y(i) )    ( -conjg(s(i))  c(i) ) ( y(i) )"],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be applied."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (1+(N-1)*INCX)",
       "         The vector x."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension (1+(N-1)*INCY)",
       "         The vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between elements of Y. INCY > 0."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is COMPLEX array, dimension (1+(N-1)*INCC)",
       "         The sines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C and S. INCC > 0."]}},
 "sla_syrcond"=>
  {"summary"=>
    ["   SLA_SYRCOND estimates the Skeel condition number of  op(A) * op2(C)",
     "   where op2 is determined by CMODE as follows",
     "   CMODE =  1    op2(C) = C",
     "   CMODE =  0    op2(C) = I",
     "   CMODE = -1    op2(C) = inv(C)",
     "   The Skeel condition number cond(A) = norminf( |inv(A)||A| )",
     "   is computed by computing scaling factors R such that",
     "   diag(R)*A*op2(C) is row equilibrated and computing the standard",
     "   infinity-norm condition number."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by SSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by SSYTRF."],
     "CMODE"=>
      ["[in]",
       "         CMODE is INTEGER",
       "    Determines op2(C) in the formula op(A) * op2(C) as follows:",
       "    CMODE =  1    op2(C) = C",
       "    CMODE =  0    op2(C) = I",
       "    CMODE = -1    op2(C) = inv(C)"],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The vector C in the formula op(A) * op2(C)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is REAL array, dimension (3*N).",
       "    Workspace."],
     "IWORK"=>
      ["[in]",
       "         IWORK is INTEGER array, dimension (N).",
       "    Workspace."]}},
 "slapmr"=>
  {"summary"=>
    ["SLAPMR rearranges the rows of the M by N matrix X as specified",
     "by the permutation K(1),K(2),...,K(M) of the integers 1,...,M.",
     "If FORWRD = .TRUE.,  forward permutation:",
     "     X(K(I),*) is moved X(I,*) for I = 1,2,...,M.",
     "If FORWRD = .FALSE., backward permutation:",
     "     X(I,*) is moved to X(K(I),*) for I = 1,2,...,M."],
   "param"=>
    {"FORWRD"=>
      ["[in]",
       "         FORWRD is LOGICAL",
       "         = .TRUE., forward permutation",
       "         = .FALSE., backward permutation"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix X. N >= 0."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,N)",
       "         On entry, the M by N matrix X.",
       "         On exit, X contains the permuted matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X, LDX >= MAX(1,M)."],
     "K"=>
      ["[in,out]",
       "         K is INTEGER array, dimension (M)",
       "         On entry, K contains the permutation vector. K is used as",
       "         internal workspace, but reset to its original value on",
       "         output."]}},
 "ctrcon"=>
  {"summary"=>
    ["CTRCON estimates the reciprocal of the condition number of a",
     "triangular matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clabrd"=>
  {"summary"=>
    ["CLABRD reduces the first NB rows and columns of a complex general",
     "m by n matrix A to upper or lower real bidiagonal form by a unitary",
     "transformation Q**H * A * P, and returns the matrices X and Y which",
     "are needed to apply the transformation to the unreduced part of A.",
     "If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower",
     "bidiagonal form.",
     "This is an auxiliary routine called by CGEBRD"],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of leading rows and columns of A to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the m by n general matrix to be reduced.",
       "         On exit, the first NB rows and columns of the matrix are",
       "         overwritten; the rest of the array is unchanged.",
       "         If m >= n, elements on and below the diagonal in the first NB",
       "           columns, with the array TAUQ, represent the unitary",
       "           matrix Q as a product of elementary reflectors; and",
       "           elements above the diagonal in the first NB rows, with the",
       "           array TAUP, represent the unitary matrix P as a product",
       "           of elementary reflectors.",
       "         If m < n, elements below the diagonal in the first NB",
       "           columns, with the array TAUQ, represent the unitary",
       "           matrix Q as a product of elementary reflectors, and",
       "           elements on and above the diagonal in the first NB rows,",
       "           with the array TAUP, represent the unitary matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (NB)",
       "         The diagonal elements of the first NB rows and columns of",
       "         the reduced matrix.  D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (NB)",
       "         The off-diagonal elements of the first NB rows and columns of",
       "         the reduced matrix."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is COMPLEX array dimension (NB)",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is COMPLEX array, dimension (NB)",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix P. See Further Details."],
     "X"=>
      ["[out]",
       "         X is COMPLEX array, dimension (LDX,NB)",
       "         The m-by-nb matrix X required to update the unreduced part",
       "         of A."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X. LDX >= max(1,M)."],
     "Y"=>
      ["[out]",
       "         Y is COMPLEX array, dimension (LDY,NB)",
       "         The n-by-nb matrix Y required to update the unreduced part",
       "         of A."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "         The leading dimension of the array Y. LDY >= max(1,N)."]}},
 "cherfs"=>
  {"summary"=>
    ["CHERFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian indefinite, and",
     "provides error bounds and backward error estimates for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The Hermitian matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "         The factored form of the matrix A.  AF contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**H or",
       "         A = L*D*L**H as computed by CHETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by CHETRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sptts2"=>
  {"summary"=>
    ["SPTTS2 solves a tridiagonal system of the form",
     "   A * X = B",
     "using the L*D*L**T factorization of A computed by SPTTRF.  D is a",
     "diagonal matrix specified in the vector D, L is a unit bidiagonal",
     "matrix whose subdiagonal is specified in the vector E, and X and B",
     "are N by NRHS matrices."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         L*D*L**T factorization of A."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the unit bidiagonal factor",
       "         L from the L*D*L**T factorization of A.  E can also be regarded",
       "         as the superdiagonal of the unit bidiagonal factor U from the",
       "         factorization A = U**T*D*U."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side vectors B for the system of",
       "         linear equations.",
       "         On exit, the solution vectors, X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."]}},
 "dsytf2_rk"=>
  {"summary"=>
    ["DSYTF2_RK computes the factorization of a real symmetric matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "zgerfsx"=>
  {"summary"=>
    ["   ZGERFSX improves the computed solution to a system of linear",
     "   equations and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED, R",
     "   and C below. In this case, the solution and error bounds returned",
     "   are for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "              diag(R).",
       "      = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "              by diag(C).",
       "      = 'B':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(R) * A * diag(C).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    The original N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The factors L and U from the factorization A = P*L*U",
       "    as computed by ZGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from ZGETRF; for 1<=i<=N, row i of the",
       "    matrix was interchanged with row IPIV(i)."],
     "R"=>
      ["[in]",
       "         R is DOUBLE PRECISION array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'R' or 'B', A is",
       "    multiplied on the left by diag(R); if EQUED = 'N' or 'C', R",
       "    is not accessed.",
       "    If R is accessed, each element of R should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A.  If EQUED = 'C' or 'B', A is",
       "    multiplied on the right by diag(C); if EQUED = 'N' or 'R', C",
       "    is not accessed.",
       "    If C is accessed, each element of C should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by ZGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is DOUBLE PRECISION array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0D+0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "sstevr"=>
  {"summary"=>
    ["SSTEVR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix T.  Eigenvalues and",
     "eigenvectors can be selected by specifying either a range of values",
     "or a range of indices for the desired eigenvalues.",
     "Whenever possible, SSTEVR calls SSTEMR to compute the",
     "eigenspectrum using Relatively Robust Representations.  SSTEMR",
     "computes eigenvalues by the dqds algorithm, while orthogonal",
     "eigenvectors are computed from various \"good\" L D L^T representations",
     "(also known as Relatively Robust Representations). Gram-Schmidt",
     "orthogonalization is avoided as far as possible. More specifically,",
     "the various steps of the algorithm are as follows. For the i-th",
     "unreduced block of T,",
     "   (a) Compute T - sigma_i = L_i D_i L_i^T, such that L_i D_i L_i^T",
     "        is a relatively robust representation,",
     "   (b) Compute the eigenvalues, lambda_j, of L_i D_i L_i^T to high",
     "       relative accuracy by the dqds algorithm,",
     "   (c) If there is a cluster of close eigenvalues, \"choose\" sigma_i",
     "       close to the cluster, and go to step (a),",
     "   (d) Given the approximate eigenvalue lambda_j of L_i D_i L_i^T,",
     "       compute the corresponding eigenvector by forming a",
     "       rank-revealing twisted factorization.",
     "The desired accuracy of the output can be specified by the input",
     "parameter ABSTOL.",
     "For more details, see \"A new O(n^2) algorithm for the symmetric",
     "tridiagonal eigenvalue/eigenvector problem\", by Inderjit Dhillon,",
     "Computer Science Division Technical Report No. UCB//CSD-97-971,",
     "UC Berkeley, May 1997.",
     "Note 1 : SSTEVR calls SSTEMR when the full spectrum is requested",
     "on machines which conform to the ieee-754 floating point standard.",
     "SSTEVR calls SSTEBZ and SSTEIN on non-ieee machines and",
     "when partial spectrum requests are made.",
     "Normal execution of SSTEMR may create NaNs and infinities and",
     "hence may abort due to a floating point exception in environments",
     "which do not handle NaNs and infinities in the ieee standard default",
     "manner."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found.",
       "         For RANGE = 'V' or 'I' and IU - IL < N - 1, SSTEBZ and",
       "         SSTEIN are called"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.",
       "         On exit, D may be multiplied by a constant factor chosen",
       "         to avoid over/underflow in computing the eigenvalues."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (max(1,N-1))",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A in elements 1 to N-1 of E.",
       "         On exit, E may be multiplied by a constant factor chosen",
       "         to avoid over/underflow in computing the eigenvalues."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3.",
       "         If high relative accuracy is important, set ABSTOL to",
       "         SLAMCH( 'Safe minimum' ).  Doing so will guarantee that",
       "         eigenvalues are computed to high relative accuracy when",
       "         possible in future releases.  The current code does not",
       "         make any guarantees about high relative accuracy, but",
       "         future releases will. See J. Barlow and J. Demmel,",
       "         \"Computing Accurate Eigensystems of Scaled Diagonally",
       "         Dominant Matrices\", LAPACK Working Note #7, for a discussion",
       "         of which matrices define their eigenvalues to high relative",
       "         accuracy."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ).",
       "         Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1"],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal (and",
       "         minimal) LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= 20*N.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal (and",
       "         minimal) LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= 10*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  Internal error"]}},
 "dlasq5"=>
  {"summary"=>
    ["DLASQ5 computes one dqds transform in ping-pong form, one",
     "version for IEEE machines another for non IEEE machines."],
   "param"=>
    {"I0"=>["[in]", "         I0 is INTEGER", "       First index."],
     "N0"=>["[in]", "         N0 is INTEGER", "       Last index."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension ( 4*N )",
       "       Z holds the qd array. EMIN is stored in Z(4*N0) to avoid",
       "       an extra argument."],
     "PP"=>
      ["[in]",
       "         PP is INTEGER",
       "       PP=0 for ping, PP=1 for pong."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION",
       "       This is the shift."],
     "SIGMA"=>
      ["[in]",
       "         SIGMA is DOUBLE PRECISION",
       "       This is the accumulated shift up to this step."],
     "DMIN"=>
      ["[out]",
       "         DMIN is DOUBLE PRECISION",
       "       Minimum value of d."],
     "DMIN1"=>
      ["[out]",
       "         DMIN1 is DOUBLE PRECISION",
       "       Minimum value of d, excluding D( N0 )."],
     "DMIN2"=>
      ["[out]",
       "         DMIN2 is DOUBLE PRECISION",
       "       Minimum value of d, excluding D( N0 ) and D( N0-1 )."],
     "DN"=>
      ["[out]",
       "         DN is DOUBLE PRECISION",
       "       d(N0), the last value of d."],
     "DNM1"=>["[out]", "         DNM1 is DOUBLE PRECISION", "       d(N0-1)."],
     "DNM2"=>["[out]", "         DNM2 is DOUBLE PRECISION", "       d(N0-2)."],
     "IEEE"=>
      ["[in]",
       "         IEEE is LOGICAL",
       "       Flag for IEEE or non IEEE arithmetic."],
     "EPS"=>
      ["[in]",
       "         EPS is DOUBLE PRECISION",
       "       This is the value of epsilon used."]}},
 "dlamswlq"=>
  {"summary"=>
    ["   DLAMQRTS overwrites the general real M-by-N matrix C with",
     "                   SIDE = 'L'     SIDE = 'R'",
     "   TRANS = 'N':      Q * C          C * Q",
     "   TRANS = 'T':      Q**T * C       C * Q**T",
     "   where Q is a real orthogonal matrix defined as the product of blocked",
     "   elementary reflectors computed by short wide LQ",
     "   factorization (DLASWLQ)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         M >= K >= 0;"],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         M >= MB >= 1"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.",
       "               MB > M."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,K)",
       "         The i-th row must contain the vector which defines the blocked",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DLASWLQ in the first k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension",
       "         ( M * Number of blocks(CEIL(N-K/NB-K)),",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "        (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,NB) * MB;",
       "         if SIDE = 'R', LWORK >= max(1,M) * MB.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sorcsd2by1"=>
  {"summary"=>[],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is computed;",
       "         otherwise:  U1 is not computed."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is computed;",
       "         otherwise:  U2 is not computed."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is computed;",
       "         otherwise:  V1T is not computed."],
     "M"=>
      ["[in]", "         M is INTEGER", "         The number of rows in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is REAL array, dimension (LDX11,Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. LDX11 >= MAX(1,P)."],
     "X21"=>
      ["[in,out]",
       "         X21 is REAL array, dimension (LDX21,Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= MAX(1,M-P)."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (R), in which R =",
       "         MIN(P,M-P,Q,M-Q).",
       "         C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and",
       "         S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) )."],
     "U1"=>
      ["[out]",
       "         U1 is REAL array, dimension (P)",
       "         If JOBU1 = 'Y', U1 contains the P-by-P orthogonal matrix U1."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of U1. If JOBU1 = 'Y', LDU1 >=",
       "         MAX(1,P)."],
     "U2"=>
      ["[out]",
       "         U2 is REAL array, dimension (M-P)",
       "         If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) orthogonal",
       "         matrix U2."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of U2. If JOBU2 = 'Y', LDU2 >=",
       "         MAX(1,M-P)."],
     "V1T"=>
      ["[out]",
       "         V1T is REAL array, dimension (Q)",
       "         If JOBV1T = 'Y', V1T contains the Q-by-Q matrix orthogonal",
       "         matrix V1**T."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >=",
       "         MAX(1,Q)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK.",
       "         If INFO > 0 on exit, WORK(2:R) contains the values PHI(1),",
       "         ..., PHI(R-1) that, together with THETA(1), ..., THETA(R),",
       "         define the matrix in intermediate bidiagonal-block form",
       "         remaining after nonconvergence. INFO specifies the number",
       "         of nonzero PHI's."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  SBBCSD did not converge. See the description of WORK",
       "               above for details."]}},
 "zunbdb2"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= min(M-P,Q,M-Q)."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX*16 array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX*16 array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is COMPLEX*16 array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is COMPLEX*16 array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is COMPLEX*16 array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slarz"=>
  {"summary"=>
    ["SLARZ applies a real elementary reflector H to a real M-by-N",
     "matrix C, from either the left or the right. H is represented in the",
     "form",
     "      H = I - tau * v * v**T",
     "where tau is a real scalar and v is a real vector.",
     "If tau = 0, then H is taken to be the unit matrix.",
     "H is a product of k elementary reflectors as returned by STZRZF."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of entries of the vector V containing",
       "         the meaningful part of the Householder vectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension (1+(L-1)*abs(INCV))",
       "         The vector v in the representation of H as returned by",
       "         STZRZF. V is not used if TAU = 0."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between elements of v. INCV <> 0."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension",
       "                        (N) if SIDE = 'L'",
       "                     or (M) if SIDE = 'R'"]}},
 "checon"=>
  {"summary"=>
    ["CHECON estimates the reciprocal of the condition number of a complex",
     "Hermitian matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by CHETRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CHETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slaed1"=>
  {"summary"=>
    ["SLAED1 computes the updated eigensystem of a diagonal",
     "matrix after modification by a rank-one symmetric matrix.  This",
     "routine is used only for the eigenproblem which requires all",
     "eigenvalues and eigenvectors of a tridiagonal matrix.  SLAED7 handles",
     "the case in which eigenvalues only or eigenvalues and eigenvectors",
     "of a full symmetric matrix (which was reduced to tridiagonal form)",
     "are desired.",
     "  T = Q(in) ( D(in) + RHO * Z*Z**T ) Q**T(in) = Q(out) * D(out) * Q**T(out)",
     "   where Z = Q**T*u, u is a vector of length N with ones in the",
     "   CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.",
     "   The eigenvectors of the original matrix are stored in Q, and the",
     "   eigenvalues are in D.  The algorithm consists of three stages:",
     "      The first stage consists of deflating the size of the problem",
     "      when there are multiple eigenvalues or if there is a zero in",
     "      the Z vector.  For each such occurrence the dimension of the",
     "      secular equation problem is reduced by one.  This stage is",
     "      performed by the routine SLAED2.",
     "      The second stage consists of calculating the updated",
     "      eigenvalues. This is done by finding the roots of the secular",
     "      equation via the routine SLAED4 (as called by SLAED3).",
     "      This routine also calculates the eigenvectors of the current",
     "      problem.",
     "      The final stage consists of computing the updated eigenvectors",
     "      directly using the updated eigenvalues.  The eigenvectors for",
     "      the current problem are multiplied with the eigenvectors from",
     "      the overall problem."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry, the eigenvalues of the rank-1-perturbed matrix.",
       "        On exit, the eigenvalues of the repaired matrix."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "        On entry, the eigenvectors of the rank-1-perturbed matrix.",
       "        On exit, the eigenvectors of the repaired tridiagonal matrix."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "INDXQ"=>
      ["[in,out]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        On entry, the permutation which separately sorts the two",
       "        subproblems in D into ascending order.",
       "        On exit, the permutation which will reintegrate the",
       "        subproblems back into sorted order,",
       "        i.e. D( INDXQ( I = 1, N ) ) will be in ascending order."],
     "RHO"=>
      ["[in]",
       "         RHO is REAL",
       "        The subdiagonal entry used to create the rank-1 modification."],
     "CUTPNT"=>
      ["[in]",
       "         CUTPNT is INTEGER",
       "        The location of the last eigenvalue in the leading sub-matrix.",
       "        min(1,N) <= CUTPNT <= N/2."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N + N**2)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, an eigenvalue did not converge"]}},
 "chetri_3x"=>
  {"summary"=>
    ["CHETRI_3X computes the inverse of a complex Hermitian indefinite",
     "matrix A using the factorization computed by CHETRF_RK or CHETRF_BK:",
     "    A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by CHETRF_RK and CHETRF_BK:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the Hermitian inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF_RK or CHETRF_BK."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX array, dimension (N+NB+1,NB+3)."],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "slasyf_aa"=>
  {"summary"=>
    ["DLATRF_AA factorizes a panel of a real symmetric matrix A using",
     "the Aasen's algorithm. The panel consists of a set of NB rows of A",
     "when UPLO is U, or a set of NB columns when UPLO is L.",
     "In order to factorize the panel, the Aasen's algorithm requires the",
     "last row, or column, of the previous panel. The first row, or column,",
     "of A is set to be the first row, or column, of an identity matrix,",
     "which is used to factorize the first panel.",
     "The resulting J-th row of U, or J-th column of L, is stored in the",
     "(J-1)-th row, or column, of A (without the unit diagonals), while",
     "the diagonal and subdiagonal of A are overwritten by those of T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The location of the first row, or column, of the panel",
       "         within the submatrix of A, passed to this routine, e.g.,",
       "         when called by SSYTRF_AA, for the first panel, J1 is 1,",
       "         while for the remaining panels, J1 is 2."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The dimension of the submatrix. M >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The dimension of the panel to be facotorized."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,M) for",
       "         the first panel, while dimension (LDA,M+1) for the",
       "         remaining panels.",
       "         On entry, A contains the last row, or column, of",
       "         the previous panel, and the trailing submatrix of A",
       "         to be factorized, except for the first panel, only",
       "         the panel is passed.",
       "         On exit, the leading panel is factorized."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the row and column interchanges,",
       "         the row and column k were interchanged with the row and",
       "         column IPIV(k)."],
     "H"=>["[in,out]", "         H is REAL workspace, dimension (LDH,NB)."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the workspace H. LDH >= max(1,M)."],
     "WORK"=>["[out]", "         WORK is REAL workspace, dimension (M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "clanhb"=>
  {"summary"=>
    ["CLANHB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n hermitian band matrix A,  with k super-diagonals.",
     "   CLANHB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANHB as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         band matrix A is supplied.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANHB is",
       "         set to zero."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of super-diagonals or sub-diagonals of the",
       "         band matrix A.  K >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The upper or lower triangle of the hermitian band matrix A,",
       "         stored in the first K+1 rows of AB.  The j-th column of A is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)   = A(i,j) for j<=i<=min(n,j+k).",
       "         Note that the imaginary parts of the diagonal elements need",
       "         not be set and are assumed to be zero."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= K+1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "zlatsqr"=>
  {"summary"=>
    ["SLATSQR computes a blocked Tall-Skinny QR factorization of",
     "an M-by-N matrix A, where M >= N:",
     "A = Q * R ."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. M >= N >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         MB > N."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal",
       "         of the array contain the N-by-N upper triangular matrix R;",
       "         the elements below the diagonal represent Q by the columns",
       "         of blocked V (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array,",
       "         dimension (LDT, N * Number_of_row_blocks)",
       "         where Number_of_row_blocks = CEIL((M-N)/(MB-N))",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.",
       "         See Further Details below."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>
      ["[out]",
       "        (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         The dimension of the array WORK.  LWORK >= NB*N.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ssytrs_3"=>
  {"summary"=>
    ["SSYTRS_3 solves a system of linear equations A * X = B with a real",
     "symmetric matrix A using the factorization computed",
     "by SSYTRF_RK or SSYTRF_BK:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This algorithm is using Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**T)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**T)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by SSYTRF_RK and SSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF_RK or SSYTRF_BK."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgetrf"=>
  {"summary"=>
    ["ZGETRF computes an LU factorization of a general M-by-N matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the right-looking Level 3 BLAS version of the algorithm."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "dlaqr1"=>
  {"summary"=>
    ["     Given a 2-by-2 or 3-by-3 matrix H, DLAQR1 sets v to a",
     "     scalar multiple of the first column of the product",
     "     (*)  K = (H - (sr1 + i*si1)*I)*(H - (sr2 + i*si2)*I)",
     "     scaling to avoid overflows and most underflows. It",
     "     is assumed that either",
     "             1) sr1 = sr2 and si1 = -si2",
     "         or",
     "             2) si1 = si2 = 0.",
     "     This is useful for starting double implicit shift bulges",
     "     in the QR algorithm."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is integer",
       "             Order of the matrix H. N must be either 2 or 3."],
     "H"=>
      ["[in]",
       "         H is DOUBLE PRECISION array of dimension (LDH,N)",
       "             The 2-by-2 or 3-by-3 matrix H in (*)."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "             The leading dimension of H as declared in",
       "             the calling procedure.  LDH.GE.N"],
     "SR1"=>["[in]", "         SR1 is DOUBLE PRECISION"],
     "SI1"=>["[in]", "         SI1 is DOUBLE PRECISION"],
     "SR2"=>["[in]", "         SR2 is DOUBLE PRECISION"],
     "SI2"=>
      ["[in]",
       "         SI2 is DOUBLE PRECISION",
       "             The shifts in (*)."],
     "V"=>
      ["[out]",
       "         V is DOUBLE PRECISION array of dimension N",
       "             A scalar multiple of the first column of the",
       "             matrix K in (*)."]}},
 "zppsv"=>
  {"summary"=>
    ["ZPPSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite matrix stored in",
     "packed format and X and B are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is a lower triangular",
     "matrix.  The factored form of A is then used to solve the system of",
     "equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**H*U or A = L*L**H, in the same storage",
       "         format as A."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "disnan"=>
  {"summary"=>
    ["DISNAN returns .TRUE. if its argument is NaN, and .FALSE.",
     "otherwise.  To be replaced by the Fortran 2003 intrinsic in the",
     "future."],
   "param"=>
    {"DIN"=>
      ["[in]",
       "         DIN is DOUBLE PRECISION",
       "         Input to test for NaN."]}},
 "dppcon"=>
  {"summary"=>
    ["DPPCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric positive definite packed matrix using",
     "the Cholesky factorization A = U**T*U or A = L*L**T computed by",
     "DPPTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, packed columnwise in a linear",
       "         array.  The j-th column of U or L is stored in the array AP",
       "         as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm (or infinity-norm) of the symmetric matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zheevx"=>
  {"summary"=>
    ["ZHEEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian matrix A.  Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= 1, when N <= 1;",
       "         otherwise 2*N.",
       "         For optimal efficiency, LWORK >= (NB+1)*N,",
       "         where NB is the max of the blocksize for ZHETRD and for",
       "         ZUNMTR as returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "zlaqr2"=>
  {"summary"=>
    ["   ZLAQR2 is identical to ZLAQR3 except that it avoids",
     "   recursion by calling ZLAHQR instead of ZLAQR4.",
     "   Aggressive early deflation:",
     "   ZLAQR2 accepts as input an upper Hessenberg matrix",
     "   H and performs an unitary similarity transformation",
     "   designed to detect and deflate fully converged eigenvalues from",
     "   a trailing principal submatrix.  On output H has been over-",
     "   written by a new Hessenberg matrix that is a perturbation of",
     "   an unitary similarity transformation of H.  It is to be",
     "   hoped that the final version of H has many zero subdiagonal",
     "   entries."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         If .TRUE., then the Hessenberg matrix H is fully updated",
       "         so that the triangular Schur factor may be",
       "         computed (in cooperation with the calling subroutine).",
       "         If .FALSE., then only enough of H is updated to preserve",
       "         the eigenvalues."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         If .TRUE., then the unitary matrix Z is updated so",
       "         so that the unitary Schur factor may be computed",
       "         (in cooperation with the calling subroutine).",
       "         If .FALSE., then Z is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H and (if WANTZ is .TRUE.) the",
       "         order of the unitary matrix Z."],
     "KTOP"=>
      ["[in]",
       "         KTOP is INTEGER",
       "         It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.",
       "         KBOT and KTOP together determine an isolated block",
       "         along the diagonal of the Hessenberg matrix."],
     "KBOT"=>
      ["[in]",
       "         KBOT is INTEGER",
       "         It is assumed without a check that either",
       "         KBOT = N or H(KBOT+1,KBOT)=0.  KBOT and KTOP together",
       "         determine an isolated block along the diagonal of the",
       "         Hessenberg matrix."],
     "NW"=>
      ["[in]",
       "         NW is INTEGER",
       "         Deflation window size.  1 .LE. NW .LE. (KBOT-KTOP+1)."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX*16 array, dimension (LDH,N)",
       "         On input the initial N-by-N section of H stores the",
       "         Hessenberg matrix undergoing aggressive early deflation.",
       "         On output H has been transformed by a unitary",
       "         similarity transformation, perturbed, and the returned",
       "         to Hessenberg form that (it is to be hoped) has some",
       "         zero subdiagonal entries."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "         Leading dimension of H just as declared in the calling",
       "         subroutine.  N .LE. LDH"],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ,N)",
       "         IF WANTZ is .TRUE., then on output, the unitary",
       "         similarity transformation mentioned above has been",
       "         accumulated into Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "         If WANTZ is .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer",
       "         The leading dimension of Z just as declared in the",
       "         calling subroutine.  1 .LE. LDZ."],
     "NS"=>
      ["[out]",
       "         NS is integer",
       "         The number of unconverged (ie approximate) eigenvalues",
       "         returned in SR and SI that may be used as shifts by the",
       "         calling subroutine."],
     "ND"=>
      ["[out]",
       "         ND is integer",
       "         The number of converged eigenvalues uncovered by this",
       "         subroutine."],
     "SH"=>
      ["[out]",
       "         SH is COMPLEX*16 array, dimension KBOT",
       "         On output, approximate eigenvalues that may",
       "         be used for shifts are stored in SH(KBOT-ND-NS+1)",
       "         through SR(KBOT-ND).  Converged eigenvalues are",
       "         stored in SH(KBOT-ND+1) through SH(KBOT)."],
     "V"=>
      ["[out]",
       "         V is COMPLEX*16 array, dimension (LDV,NW)",
       "         An NW-by-NW work array."],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "         The leading dimension of V just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "         The number of columns of T.  NH.GE.NW."],
     "T"=>["[out]", "         T is COMPLEX*16 array, dimension (LDT,NW)"],
     "LDT"=>
      ["[in]",
       "         LDT is integer",
       "         The leading dimension of T just as declared in the",
       "         calling subroutine.  NW .LE. LDT"],
     "NV"=>
      ["[in]",
       "         NV is integer",
       "         The number of rows of work array WV available for",
       "         workspace.  NV.GE.NW."],
     "WV"=>["[out]", "         WV is COMPLEX*16 array, dimension (LDWV,NW)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer",
       "         The leading dimension of W just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension LWORK.",
       "         On exit, WORK(1) is set to an estimate of the optimal value",
       "         of LWORK for the given values of N, NW, KTOP and KBOT."],
     "LWORK"=>
      ["[in]",
       "         LWORK is integer",
       "         The dimension of the work array WORK.  LWORK = 2*NW",
       "         suffices, but greater efficiency may result from larger",
       "         values of LWORK.",
       "         If LWORK = -1, then a workspace query is assumed; ZLAQR2",
       "         only estimates the optimal workspace size for the given",
       "         values of N, NW, KTOP and KBOT.  The estimate is returned",
       "         in WORK(1).  No error message related to LWORK is issued",
       "         by XERBLA.  Neither H nor Z are accessed."]}},
 "clascl2"=>
  {"summary"=>
    ["CLASCL2 performs a diagonal scaling on a vector:",
     "  x <-- D * x",
     "where the diagonal REAL matrix D is stored as a vector.",
     "Eventually to be replaced by BLAS_cge_diag_scale in the new BLAS",
     "standard."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "    The number of rows of D and X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of columns of X. N >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, length M",
       "    Diagonal matrix D, stored as a vector of length M."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,N)",
       "    On entry, the vector X to be scaled by D.",
       "    On exit, the scaled vector."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the vector X. LDX >= M."]}},
 "dla_porpvgrw"=>
  {"summary"=>
    ["DLA_PORPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A. NCOLS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by DPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "WORK"=>
      ["[in]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"]}},
 "zgeev"=>
  {"summary"=>
    ["ZGEEV computes for an N-by-N complex nonsymmetric matrix A, the",
     "eigenvalues and, optionally, the left and/or right eigenvectors.",
     "The right eigenvector v(j) of A satisfies",
     "                 A * v(j) = lambda(j) * v(j)",
     "where lambda(j) is its eigenvalue.",
     "The left eigenvector u(j) of A satisfies",
     "              u(j)**H * A = lambda(j) * u(j)**H",
     "where u(j)**H denotes the conjugate transpose of u(j).",
     "The computed eigenvectors are normalized to have Euclidean norm",
     "equal to 1 and largest component real."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N': left eigenvectors of A are not computed;",
       "         = 'V': left eigenvectors of are computed."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N': right eigenvectors of A are not computed;",
       "         = 'V': right eigenvectors of A are computed."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX*16 array, dimension (N)",
       "         W contains the computed eigenvalues."],
     "VL"=>
      ["[out]",
       "         VL is COMPLEX*16 array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order",
       "         as their eigenvalues.",
       "         If JOBVL = 'N', VL is not referenced.",
       "         u(j) = VL(:,j), the j-th column of VL."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1; if",
       "         JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is COMPLEX*16 array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order",
       "         as their eigenvalues.",
       "         If JOBVR = 'N', VR is not referenced.",
       "         v(j) = VR(:,j), the j-th column of VR."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1; if",
       "         JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,2*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the QR algorithm failed to compute all the",
       "               eigenvalues, and no eigenvectors have been computed;",
       "               elements and i+1:N of W contain eigenvalues which have",
       "               converged."]}},
 "claqgb"=>
  {"summary"=>
    ["CLAQGB equilibrates a general M by N band matrix A with KL",
     "subdiagonals and KU superdiagonals using the row and scaling factors",
     "in the vectors R and C."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, the equilibrated matrix, in the same storage format",
       "         as A.  See EQUED for the form of the equilibrated matrix."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDA >= KL+KU+1."],
     "R"=>
      ["[in]",
       "         R is REAL array, dimension (M)",
       "         The row scale factors for A."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "         The column scale factors for A."],
     "ROWCND"=>
      ["[in]",
       "         ROWCND is REAL",
       "         Ratio of the smallest R(i) to the largest R(i)."],
     "COLCND"=>
      ["[in]",
       "         COLCND is REAL",
       "         Ratio of the smallest C(i) to the largest C(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies the form of equilibration that was done.",
       "         = 'N':  No equilibration",
       "         = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "                 diag(R).",
       "         = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "                 by diag(C).",
       "         = 'B':  Both row and column equilibration, i.e., A has been",
       "                 replaced by diag(R) * A * diag(C)."]}},
 "ztfsm"=>
  {"summary"=>
    ["Level 3 BLAS like routine for A in RFP Format.",
     "ZTFSM  solves the matrix equation",
     "   op( A )*X = alpha*B  or  X*op( A ) = alpha*B",
     "where alpha is a scalar, X and B are m by n matrices, A is a unit, or",
     "non-unit,  upper or lower triangular matrix  and  op( A )  is one  of",
     "   op( A ) = A   or   op( A ) = A**H.",
     "A is in Rectangular Full Packed (RFP) Format.",
     "The matrix X is overwritten on B."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal Form of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose Form of RFP A is stored."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "          On entry, SIDE specifies whether op( A ) appears on the left",
       "          or right of X as follows:",
       "             SIDE = 'L' or 'l'   op( A )*X = alpha*B.",
       "             SIDE = 'R' or 'r'   X*op( A ) = alpha*B.",
       "          Unchanged on exit."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the RFP matrix A came from",
       "          an upper or lower triangular matrix as follows:",
       "          UPLO = 'U' or 'u' RFP A came from an upper triangular matrix",
       "          UPLO = 'L' or 'l' RFP A came from a  lower triangular matrix",
       "          Unchanged on exit."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "          On entry, TRANS  specifies the form of op( A ) to be used",
       "          in the matrix multiplication as follows:",
       "             TRANS  = 'N' or 'n'   op( A ) = A.",
       "             TRANS  = 'C' or 'c'   op( A ) = conjg( A' ).",
       "          Unchanged on exit."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "          On entry, DIAG specifies whether or not RFP A is unit",
       "          triangular as follows:",
       "             DIAG = 'U' or 'u'   A is assumed to be unit triangular.",
       "             DIAG = 'N' or 'n'   A is not assumed to be unit",
       "                                 triangular.",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of B. M must be at",
       "          least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of B.  N must be",
       "          at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX*16",
       "          On entry,  ALPHA specifies the scalar  alpha. When  alpha is",
       "          zero then  A is not referenced and  B need not be set before",
       "          entry.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "          NT = N*(N+1)/2. On entry, the matrix A in RFP Format.",
       "          RFP Format is described by TRANSR, UPLO and N as follows:",
       "          If TRANSR='N' then RFP A is (0:N,0:K-1) when N is even;",
       "          K=N/2. RFP A is (0:N-1,0:K) when N is odd; K=N/2. If",
       "          TRANSR = 'C' then RFP is the Conjugate-transpose of RFP A as",
       "          defined when TRANSR = 'N'. The contents of RFP A are defined",
       "          by UPLO as follows: If UPLO = 'U' the RFP A contains the NT",
       "          elements of upper packed A either in normal or",
       "          conjugate-transpose Format. If UPLO = 'L' the RFP A contains",
       "          the NT elements of lower packed A either in normal or",
       "          conjugate-transpose Format. The LDA of RFP A is (N+1)/2 when",
       "          TRANSR = 'C'. When TRANSR is 'N' the LDA is N+1 when N is",
       "          even and is N when is odd.",
       "          See the Note below for more details. Unchanged on exit."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "          Before entry,  the leading  m by n part of the array  B must",
       "          contain  the  right-hand  side  matrix  B,  and  on exit  is",
       "          overwritten by the solution matrix  X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "          On entry, LDB specifies the first dimension of B as declared",
       "          in  the  calling  (sub)  program.   LDB  must  be  at  least",
       "          max( 1, m ).",
       "          Unchanged on exit."]}},
 "dlasv2"=>
  {"summary"=>
    ["DLASV2 computes the singular value decomposition of a 2-by-2",
     "triangular matrix",
     "   [  F   G  ]",
     "   [  0   H  ].",
     "On return, abs(SSMAX) is the larger singular value, abs(SSMIN) is the",
     "smaller singular value, and (CSL,SNL) and (CSR,SNR) are the left and",
     "right singular vectors for abs(SSMAX), giving the decomposition",
     "   [ CSL  SNL ] [  F   G  ] [ CSR -SNR ]  =  [ SSMAX   0   ]",
     "   [-SNL  CSL ] [  0   H  ] [ SNR  CSR ]     [  0    SSMIN ]."],
   "param"=>
    {"F"=>
      ["[in]",
       "         F is DOUBLE PRECISION",
       "         The (1,1) element of the 2-by-2 matrix."],
     "G"=>
      ["[in]",
       "         G is DOUBLE PRECISION",
       "         The (1,2) element of the 2-by-2 matrix."],
     "H"=>
      ["[in]",
       "         H is DOUBLE PRECISION",
       "         The (2,2) element of the 2-by-2 matrix."],
     "SSMIN"=>
      ["[out]",
       "         SSMIN is DOUBLE PRECISION",
       "         abs(SSMIN) is the smaller singular value."],
     "SSMAX"=>
      ["[out]",
       "         SSMAX is DOUBLE PRECISION",
       "         abs(SSMAX) is the larger singular value."],
     "SNL"=>["[out]", "         SNL is DOUBLE PRECISION"],
     "CSL"=>
      ["[out]",
       "         CSL is DOUBLE PRECISION",
       "         The vector (CSL, SNL) is a unit left singular vector for the",
       "         singular value abs(SSMAX)."],
     "SNR"=>["[out]", "         SNR is DOUBLE PRECISION"],
     "CSR"=>
      ["[out]",
       "         CSR is DOUBLE PRECISION",
       "         The vector (CSR, SNR) is a unit right singular vector for the",
       "         singular value abs(SSMAX)."]}},
 "slasq6"=>
  {"summary"=>
    ["SLASQ6 computes one dqd (shift equal to zero) transform in",
     "ping-pong form, with protection against underflow and overflow."],
   "param"=>
    {"I0"=>["[in]", "         I0 is INTEGER", "       First index."],
     "N0"=>["[in]", "         N0 is INTEGER", "       Last index."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension ( 4*N )",
       "       Z holds the qd array. EMIN is stored in Z(4*N0) to avoid",
       "       an extra argument."],
     "PP"=>
      ["[in]",
       "         PP is INTEGER",
       "       PP=0 for ping, PP=1 for pong."],
     "DMIN"=>["[out]", "         DMIN is REAL", "       Minimum value of d."],
     "DMIN1"=>
      ["[out]",
       "         DMIN1 is REAL",
       "       Minimum value of d, excluding D( N0 )."],
     "DMIN2"=>
      ["[out]",
       "         DMIN2 is REAL",
       "       Minimum value of d, excluding D( N0 ) and D( N0-1 )."],
     "DN"=>
      ["[out]", "         DN is REAL", "       d(N0), the last value of d."],
     "DNM1"=>["[out]", "         DNM1 is REAL", "       d(N0-1)."],
     "DNM2"=>["[out]", "         DNM2 is REAL", "       d(N0-2)."]}},
 "sgghrd"=>
  {"summary"=>
    ["SGGHRD reduces a pair of real matrices (A,B) to generalized upper",
     "Hessenberg form using orthogonal transformations, where A is a",
     "general matrix and B is upper triangular.  The form of the",
     "generalized eigenvalue problem is",
     "   A*x = lambda*B*x,",
     "and B is typically made upper triangular by computing its QR",
     "factorization and moving the orthogonal matrix Q to the left side",
     "of the equation.",
     "This subroutine simultaneously reduces A to a Hessenberg matrix H:",
     "   Q**T*A*Z = H",
     "and transforms B to another upper triangular matrix T:",
     "   Q**T*B*Z = T",
     "in order to reduce the problem to its standard form",
     "   H*y = lambda*T*y",
     "where y = Z**T*x.",
     "The orthogonal matrices Q and Z are determined as products of Givens",
     "rotations.  They may either be formed explicitly, or they may be",
     "postmultiplied into input matrices Q1 and Z1, so that",
     "     Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T",
     "     Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T",
     "If Q1 is the orthogonal matrix from the QR factorization of B in the",
     "original equation A*x = lambda*B*x, then SGGHRD reduces the original",
     "problem to generalized Hessenberg form."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': do not compute Q;",
       "         = 'I': Q is initialized to the unit matrix, and the",
       "                orthogonal matrix Q is returned;",
       "         = 'V': Q must contain an orthogonal matrix Q1 on entry,",
       "                and the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': do not compute Z;",
       "         = 'I': Z is initialized to the unit matrix, and the",
       "                orthogonal matrix Z is returned;",
       "         = 'V': Z must contain an orthogonal matrix Z1 on entry,",
       "                and the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of A which are to be",
       "         reduced.  It is assumed that A is already upper triangular",
       "         in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are",
       "         normally set by a previous call to SGGBAL; otherwise they",
       "         should be set to 1 and N respectively.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         rest is set to zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, the N-by-N upper triangular matrix B.",
       "         On exit, the upper triangular matrix T = Q**T B Z.  The",
       "         elements below the diagonal are set to zero."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the orthogonal matrix Q1,",
       "         typically from the QR factorization of B.",
       "         On exit, if COMPQ='I', the orthogonal matrix Q, and if",
       "         COMPQ = 'V', the product Q1*Q.",
       "         Not referenced if COMPQ='N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the orthogonal matrix Z1.",
       "         On exit, if COMPZ='I', the orthogonal matrix Z, and if",
       "         COMPZ = 'V', the product Z1*Z.",
       "         Not referenced if COMPZ='N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.",
       "         LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slag2d"=>
  {"summary"=>
    ["SLAG2D converts a SINGLE PRECISION matrix, SA, to a DOUBLE",
     "PRECISION matrix, A.",
     "Note that while it is possible to overflow while converting",
     "from double to single, it is not possible to overflow when",
     "converting from single to double.",
     "This is an auxiliary routine so there is no argument checking."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of lines of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "SA"=>
      ["[in]",
       "         SA is REAL array, dimension (LDSA,N)",
       "         On entry, the M-by-N coefficient matrix SA."],
     "LDSA"=>
      ["[in]",
       "         LDSA is INTEGER",
       "         The leading dimension of the array SA.  LDSA >= max(1,M)."],
     "A"=>
      ["[out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On exit, the M-by-N coefficient matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit"]}},
 "dlarra"=>
  {"summary"=>
    ["Compute the splitting points with threshold SPLTOL.",
     "DLARRA sets any \"small\" off-diagonal elements to zero."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix. N > 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal",
       "         matrix T."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the first (N-1) entries contain the subdiagonal",
       "         elements of the tridiagonal matrix T; E(N) need not be set.",
       "         On exit, the entries E( ISPLIT( I ) ), 1 <= I <= NSPLIT,",
       "         are set to zero, the other entries of E are untouched."],
     "E2"=>
      ["[in,out]",
       "         E2 is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the first (N-1) entries contain the SQUARES of the",
       "         subdiagonal elements of the tridiagonal matrix T;",
       "         E2(N) need not be set.",
       "         On exit, the entries E2( ISPLIT( I ) ),",
       "         1 <= I <= NSPLIT, have been set to zero"],
     "SPLTOL"=>
      ["[in]",
       "         SPLTOL is DOUBLE PRECISION",
       "         The threshold for splitting. Two criteria can be used:",
       "         SPLTOL<0 : criterion based on absolute off-diagonal value",
       "         SPLTOL>0 : criterion that preserves relative accuracy"],
     "TNRM"=>
      ["[in]",
       "         TNRM is DOUBLE PRECISION",
       "         The norm of the matrix."],
     "NSPLIT"=>
      ["[out]",
       "         NSPLIT is INTEGER",
       "         The number of blocks T splits into. 1 <= NSPLIT <= N."],
     "ISPLIT"=>
      ["[out]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into blocks.",
       "         The first block consists of rows/columns 1 to ISPLIT(1),",
       "         the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),",
       "         etc., and the NSPLIT-th consists of rows/columns",
       "         ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit"]}},
 "dlamtsqr"=>
  {"summary"=>
    ["     DLAMTSQR overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "     where Q is a real orthogonal matrix defined as the product",
     "     of blocked elementary reflectors computed by tall skinny",
     "     QR factorization (DLATSQR)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         N >= K >= 0;"],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.",
       "         MB > N. (must be the same as DLATSQR)"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         blockedelementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by DLATSQR in the first k columns of",
       "         its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension",
       "         ( N * Number of blocks(CEIL(M-K/MB-K)),",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "        (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N)*NB;",
       "         if SIDE = 'R', LWORK >= max(1,MB)*NB.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dstevx"=>
  {"summary"=>
    ["DSTEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix A.  Eigenvalues and",
     "eigenvectors can be selected by specifying either a range of values",
     "or a range of indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.",
       "         On exit, D may be multiplied by a constant factor chosen",
       "         to avoid over/underflow in computing the eigenvalues."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (max(1,N-1))",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A in elements 1 to N-1 of E.",
       "         On exit, E may be multiplied by a constant factor chosen",
       "         to avoid over/underflow in computing the eigenvalues."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less",
       "         than or equal to zero, then  EPS*|T|  will be used in",
       "         its place, where |T| is the 1-norm of the tridiagonal",
       "         matrix.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge (INFO > 0), then that",
       "         column of Z contains the latest approximation to the",
       "         eigenvector, and the index of the eigenvector is returned",
       "         in IFAIL.  If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (5*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "ssbgvd"=>
  {"summary"=>
    ["SSBGVD computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite banded eigenproblem, of the",
     "form A*x=(lambda)*B*x.  Here A and B are assumed to be symmetric and",
     "banded, and B is also positive definite.  If eigenvectors are",
     "desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is REAL array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(ka+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**T*S, as returned by SPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i).  The eigenvectors are",
       "         normalized so Z**T*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LWORK >= 3*N.",
       "         If JOBZ = 'V' and N > 1, LWORK >= 1 + 5*N + 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if LIWORK > 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK >= 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is:",
       "            <= N:  the algorithm failed to converge:",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then SPBSTF",
       "                   returned INFO = i: B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "dlascl2"=>
  {"summary"=>
    ["DLASCL2 performs a diagonal scaling on a vector:",
     "  x <-- D * x",
     "where the diagonal matrix D is stored as a vector.",
     "Eventually to be replaced by BLAS_dge_diag_scale in the new BLAS",
     "standard."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "    The number of rows of D and X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of columns of X. N >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, length M",
       "    Diagonal matrix D, stored as a vector of length M."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,N)",
       "    On entry, the vector X to be scaled by D.",
       "    On exit, the scaled vector."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the vector X. LDX >= M."]}},
 "slarfg"=>
  {"summary"=>
    ["SLARFG generates a real elementary reflector H of order n, such",
     "that",
     "      H * ( alpha ) = ( beta ),   H**T * H = I.",
     "          (   x   )   (   0  )",
     "where alpha and beta are scalars, and x is an (n-1)-element real",
     "vector. H is represented in the form",
     "      H = I - tau * ( 1 ) * ( 1 v**T ) ,",
     "                    ( v )",
     "where tau is a real scalar and v is a real (n-1)-element",
     "vector.",
     "If the elements of x are all zero, then tau = 0 and H is taken to be",
     "the unit matrix.",
     "Otherwise  1 <= tau <= 2."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the elementary reflector."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is REAL",
       "         On entry, the value alpha.",
       "         On exit, it is overwritten with the value beta."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension",
       "                        (1+(N-2)*abs(INCX))",
       "         On entry, the vector x.",
       "         On exit, it is overwritten with the vector v."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "TAU"=>["[out]", "         TAU is REAL", "         The value tau."]}},
 "dsysv_aa"=>
  {"summary"=>
    ["DSYSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "Aasen's algorithm is used to factor A as",
     "   A = U * T * U**T,  if UPLO = 'U', or",
     "   A = L * T * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is symmetric tridiagonal. The factored",
     "form of A is then used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the tridiagonal matrix T and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*T*U**T or A = L*T*L**T as computed by",
       "         DSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= MAX(1,2*N,3*N-2), and for",
       "         the best performance, LWORK >= MAX(1,N*NB), where NB is",
       "         the optimal blocksize for DSYTRF_AA.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "slae2"=>
  {"summary"=>
    ["SLAE2  computes the eigenvalues of a 2-by-2 symmetric matrix",
     "   [  A   B  ]",
     "   [  B   C  ].",
     "On return, RT1 is the eigenvalue of larger absolute value, and RT2",
     "is the eigenvalue of smaller absolute value."],
   "param"=>
    {"A"=>
      ["[in]",
       "         A is REAL",
       "         The (1,1) element of the 2-by-2 matrix."],
     "B"=>
      ["[in]",
       "         B is REAL",
       "         The (1,2) and (2,1) elements of the 2-by-2 matrix."],
     "C"=>
      ["[in]",
       "         C is REAL",
       "         The (2,2) element of the 2-by-2 matrix."],
     "RT1"=>
      ["[out]",
       "         RT1 is REAL",
       "         The eigenvalue of larger absolute value."],
     "RT2"=>
      ["[out]",
       "         RT2 is REAL",
       "         The eigenvalue of smaller absolute value."]}},
 "sorbdb4"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M and",
       "          M-Q <= min(P,M-P,Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is REAL array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is REAL array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is REAL array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is REAL array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is REAL array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is REAL array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "PHANTOM"=>
      ["[out]",
       "         PHANTOM is REAL array, dimension (M)",
       "          The routine computes an M-by-1 column vector Y that is",
       "          orthogonal to the columns of [ X11; X21 ]. PHANTOM(1:P) and",
       "          PHANTOM(P+1:M) contain Householder vectors for Y(1:P) and",
       "          Y(P+1:M), respectively."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dlarrv"=>
  {"summary"=>
    ["DLARRV computes the eigenvectors of the tridiagonal matrix",
     "T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T.",
     "The input eigenvalues should have been computed by DLARRE."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         Lower bound of the interval that contains the desired",
       "         eigenvalues. VL < VU. Needed to compute gaps on the left or right",
       "         end of the extremal eigenvalues in the desired RANGE."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         Upper bound of the interval that contains the desired",
       "         eigenvalues. VL < VU. Needed to compute gaps on the left or right",
       "         end of the extremal eigenvalues in the desired RANGE."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the N diagonal elements of the diagonal matrix D.",
       "         On exit, D may be overwritten."],
     "L"=>
      ["[in,out]",
       "         L is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the unit",
       "         bidiagonal matrix L are in elements 1 to N-1 of L",
       "         (if the matrix is not split.) At the end of each block",
       "         is stored the corresponding shift as given by DLARRE.",
       "         On exit, L is overwritten."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "         The minimum pivot allowed in the Sturm sequence."],
     "ISPLIT"=>
      ["[in]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into blocks.",
       "         The first block consists of rows/columns 1 to",
       "         ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1",
       "         through ISPLIT( 2 ), etc."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of input eigenvalues.  0 <= M <= N."],
     "DOL"=>["[in]", "         DOL is INTEGER"],
     "DOU"=>
      ["[in]",
       "         DOU is INTEGER",
       "         If the user wants to compute only selected eigenvectors from all",
       "         the eigenvalues supplied, he can specify an index range DOL:DOU.",
       "         Or else the setting DOL=1, DOU=M should be applied.",
       "         Note that DOL and DOU refer to the order in which the eigenvalues",
       "         are stored in W.",
       "         If the user wants to compute only selected eigenpairs, then",
       "         the columns DOL-1 to DOU+1 of the eigenvector space Z contain the",
       "         computed eigenvectors. All other columns of Z are set to zero."],
     "MINRGP"=>["[in]", "         MINRGP is DOUBLE PRECISION"],
     "RTOL1"=>["[in]", "         RTOL1 is DOUBLE PRECISION"],
     "RTOL2"=>
      ["[in]",
       "         RTOL2 is DOUBLE PRECISION",
       "          Parameters for bisection.",
       "          An interval [LEFT,RIGHT] has converged if",
       "          RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )"],
     "W"=>
      ["[in,out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements of W contain the APPROXIMATE eigenvalues for",
       "         which eigenvectors are to be computed.  The eigenvalues",
       "         should be grouped by split-off block and ordered from",
       "         smallest to largest within the block ( The output array",
       "         W from DLARRE is expected here ). Furthermore, they are with",
       "         respect to the shift of the corresponding root representation",
       "         for their block. On exit, W holds the eigenvalues of the",
       "         UNshifted matrix."],
     "WERR"=>
      ["[in,out]",
       "         WERR is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the semiwidth of the uncertainty",
       "         interval of the corresponding eigenvalue in W"],
     "WGAP"=>
      ["[in,out]",
       "         WGAP is DOUBLE PRECISION array, dimension (N)",
       "         The separation from the right neighbor eigenvalue in W."],
     "IBLOCK"=>
      ["[in]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         The indices of the blocks (submatrices) associated with the",
       "         corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue",
       "         W(i) belongs to the first block from the top, =2 if W(i)",
       "         belongs to the second block, etc."],
     "INDEXW"=>
      ["[in]",
       "         INDEXW is INTEGER array, dimension (N)",
       "         The indices of the eigenvalues within each block (submatrix);",
       "         for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the",
       "         i-th eigenvalue W(i) is the 10-th eigenvalue in the second block."],
     "GERS"=>
      ["[in]",
       "         GERS is DOUBLE PRECISION array, dimension (2*N)",
       "         The N Gerschgorin intervals (the i-th Gerschgorin interval",
       "         is (GERS(2*i-1), GERS(2*i)). The Gerschgorin intervals should",
       "         be computed from the original UNshifted matrix."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M) )",
       "         If INFO = 0, the first M columns of Z contain the",
       "         orthonormal eigenvectors of the matrix T",
       "         corresponding to the input eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The I-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*I-1 ) through",
       "         ISUPPZ( 2*I )."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (12*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (7*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         > 0:  A problem occurred in DLARRV.",
       "         < 0:  One of the called subroutines signaled an internal problem.",
       "               Needs inspection of the corresponding parameter IINFO",
       "               for further information.",
       "         =-1:  Problem in DLARRB when refining a child's eigenvalues.",
       "         =-2:  Problem in DLARRF when computing the RRR of a child.",
       "               When a child is inside a tight cluster, it can be difficult",
       "               to find an RRR. A partial remedy from the user's point of",
       "               view is to make the parameter MINRGP smaller and recompile.",
       "               However, as the orthogonality of the computed vectors is",
       "               proportional to 1/MINRGP, the user should be aware that",
       "               he might be trading in precision when he decreases MINRGP.",
       "         =-3:  Problem in DLARRB when refining a single eigenvalue",
       "               after the Rayleigh correction was rejected.",
       "         = 5:  The Rayleigh Quotient Iteration failed to converge to",
       "               full accuracy in MAXITR steps."]}},
 "cptrfs"=>
  {"summary"=>
    ["CPTRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian positive definite",
     "and tridiagonal, and provides error bounds and backward error",
     "estimates for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the superdiagonal or the subdiagonal of the",
       "         tridiagonal matrix A is stored and the form of the",
       "         factorization:",
       "         = 'U':  E is the superdiagonal of A, and A = U**H*D*U;",
       "         = 'L':  E is the subdiagonal of A, and A = L*D*L**H.",
       "         (The two forms are equivalent if A is real.)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n real diagonal elements of the tridiagonal matrix A."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the tridiagonal matrix A",
       "         (see UPLO)."],
     "DF"=>
      ["[in]",
       "         DF is REAL array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from",
       "         the factorization computed by CPTTRF."],
     "EF"=>
      ["[in]",
       "         EF is COMPLEX array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the unit bidiagonal",
       "         factor U or L from the factorization computed by CPTTRF",
       "         (see UPLO)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by CPTTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j)."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "csyconvf_rook"=>
  {"summary"=>
    ["If parameter WAY = 'C':",
     "CSYCONVF_ROOK converts the factorization output format used in",
     "CSYTRF_ROOK provided on entry in parameter A into the factorization",
     "output format used in CSYTRF_RK (or CSYTRF_BK) that is stored",
     "on exit in parameters A and E. IPIV format for CSYTRF_ROOK and",
     "CSYTRF_RK (or CSYTRF_BK) is the same and is not converted.",
     "If parameter WAY = 'R':",
     "CSYCONVF_ROOK performs the conversion in reverse direction, i.e.",
     "converts the factorization output format used in CSYTRF_RK",
     "(or CSYTRF_BK) provided on entry in parametes A and E into",
     "the factorization output format used in CSYTRF_ROOK that is stored",
     "on exit in parameter A. IPIV format for CSYTRF_ROOK and",
     "CSYTRF_RK (or CSYTRF_BK) is the same and is not converted.",
     "CSYCONVF_ROOK can also convert in Hermitian matrix case, i.e. between",
     "formats used in CHETRF_ROOK and CHETRF_RK (or CHETRF_BK)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix A.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         1) If WAY ='C':",
       "         On entry, contains factorization details in format used in",
       "         CSYTRF_ROOK:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         CSYTRF_RK or CSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         2) If WAY = 'R':",
       "         On entry, contains factorization details in format used in",
       "         CSYTRF_RK or CSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         CSYTRF_ROOK:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in,out]",
       "         E is COMPLEX array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, just a workspace.",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         2) If WAY = 'R':",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not referenced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         On exit, is not changed"],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On entry, details of the interchanges and the block",
       "         structure of D as determined:",
       "         1) by CSYTRF_ROOK, if WAY ='C';",
       "         2) by CSYTRF_RK (or CSYTRF_BK), if WAY ='R'.",
       "         The IPIV format is the same for all these routines.",
       "         On exit, is not changed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlacn2"=>
  {"summary"=>
    ["ZLACN2 estimates the 1-norm of a square, complex matrix A.",
     "Reverse communication is used for evaluating matrix-vector products."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The order of the matrix.  N >= 1."],
     "V"=>
      ["[out]",
       "         V is COMPLEX*16 array, dimension (N)",
       "        On the final return, V = A*W,  where  EST = norm(V)/norm(W)",
       "        (W is not returned)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (N)",
       "        On an intermediate return, X should be overwritten by",
       "              A * X,   if KASE=1,",
       "              A**H * X,  if KASE=2,",
       "        where A**H is the conjugate transpose of A, and ZLACN2 must be",
       "        re-called with all the other parameters unchanged."],
     "EST"=>
      ["[in,out]",
       "         EST is DOUBLE PRECISION",
       "        On entry with KASE = 1 or 2 and ISAVE(1) = 3, EST should be",
       "        unchanged from the previous call to ZLACN2.",
       "        On exit, EST is an estimate (a lower bound) for norm(A)."],
     "KASE"=>
      ["[in,out]",
       "         KASE is INTEGER",
       "        On the initial call to ZLACN2, KASE should be 0.",
       "        On an intermediate return, KASE will be 1 or 2, indicating",
       "        whether X should be overwritten by A * X  or A**H * X.",
       "        On the final return from ZLACN2, KASE will again be 0."],
     "ISAVE"=>
      ["[in,out]",
       "         ISAVE is INTEGER array, dimension (3)",
       "        ISAVE is used to save variables between calls to ZLACN2"]}},
 "cheevx_2stage"=>
  {"summary"=>
    ["CHEEVX_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, 8*N, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "dgelq"=>
  {"summary"=>["DGELQ computes a LQ factorization of an M-by-N matrix A."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the M-by-min(M,N) lower trapezoidal matrix L",
       "         (L is lower triangular if M <= N);",
       "         the elements above the diagonal are used to store part of the ",
       "         data structure to represent Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (MAX(5,TSIZE))",
       "         On exit, if INFO = 0, T(1) returns optimal (or either minimal ",
       "         or optimal, if query is assumed) TSIZE. See TSIZE for details.",
       "         Remaining T contains part of the data structure used to represent Q.",
       "         If one wants to apply or construct Q, then one needs to keep T ",
       "         (in addition to A) and pass it to further subroutines."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         If TSIZE >= 5, the dimension of the array T.",
       "         If TSIZE = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If TSIZE = -1, the routine calculates optimal size of T for the ",
       "         optimum performance and returns this value in T(1).",
       "         If TSIZE = -2, the routine calculates minimal size of T and ",
       "         returns this value in T(1)."],
     "WORK"=>
      ["[out]",
       "         (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zdrscl"=>
  {"summary"=>
    ["ZDRSCL multiplies an n-element complex vector x by the real scalar",
     "1/a.  This is done without overflow or underflow as long as",
     "the final result x/a does not overflow or underflow."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of components of the vector x."],
     "SA"=>
      ["[in]",
       "         SA is DOUBLE PRECISION",
       "         The scalar a which is used to divide each component of x.",
       "         SA must be >= 0, or the subroutine will divide by zero."],
     "SX"=>
      ["[in,out]",
       "         SX is COMPLEX*16 array, dimension",
       "                        (1+(N-1)*abs(INCX))",
       "         The n-element vector x."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of the vector SX.",
       "         > 0:  SX(1) = X(1) and SX(1+(i-1)*INCX) = x(i),     1< i<= n"]}},
 "dpotf2"=>
  {"summary"=>
    ["DPOTF2 computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**T * U ,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**T *U  or A = L*L**T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite, and the factorization could not be",
       "              completed."]}},
 "dlasy2"=>
  {"summary"=>
    ["DLASY2 solves for the N1 by N2 matrix X, 1 <= N1,N2 <= 2, in",
     "       op(TL)*X + ISGN*X*op(TR) = SCALE*B,",
     "where TL is N1 by N1, TR is N2 by N2, B is N1 by N2, and ISGN = 1 or",
     "-1.  op(T) = T or T**T, where T**T denotes the transpose of T."],
   "param"=>
    {"LTRANL"=>
      ["[in]",
       "         LTRANL is LOGICAL",
       "         On entry, LTRANL specifies the op(TL):",
       "            = .FALSE., op(TL) = TL,",
       "            = .TRUE., op(TL) = TL**T."],
     "LTRANR"=>
      ["[in]",
       "         LTRANR is LOGICAL",
       "         On entry, LTRANR specifies the op(TR):",
       "           = .FALSE., op(TR) = TR,",
       "           = .TRUE., op(TR) = TR**T."],
     "ISGN"=>
      ["[in]",
       "         ISGN is INTEGER",
       "         On entry, ISGN specifies the sign of the equation",
       "         as described before. ISGN may only be 1 or -1."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         On entry, N1 specifies the order of matrix TL.",
       "         N1 may only be 0, 1 or 2."],
     "N2"=>
      ["[in]",
       "         N2 is INTEGER",
       "         On entry, N2 specifies the order of matrix TR.",
       "         N2 may only be 0, 1 or 2."],
     "TL"=>
      ["[in]",
       "         TL is DOUBLE PRECISION array, dimension (LDTL,2)",
       "         On entry, TL contains an N1 by N1 matrix."],
     "LDTL"=>
      ["[in]",
       "         LDTL is INTEGER",
       "         The leading dimension of the matrix TL. LDTL >= max(1,N1)."],
     "TR"=>
      ["[in]",
       "         TR is DOUBLE PRECISION array, dimension (LDTR,2)",
       "         On entry, TR contains an N2 by N2 matrix."],
     "LDTR"=>
      ["[in]",
       "         LDTR is INTEGER",
       "         The leading dimension of the matrix TR. LDTR >= max(1,N2)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,2)",
       "         On entry, the N1 by N2 matrix B contains the right-hand",
       "         side of the equation."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the matrix B. LDB >= max(1,N1)."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         On exit, SCALE contains the scale factor. SCALE is chosen",
       "         less than or equal to 1 to prevent the solution overflowing."],
     "X"=>
      ["[out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,2)",
       "         On exit, X contains the N1 by N2 solution."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the matrix X. LDX >= max(1,N1)."],
     "XNORM"=>
      ["[out]",
       "         XNORM is DOUBLE PRECISION",
       "         On exit, XNORM is the infinity-norm of the solution."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO is set to",
       "            0: successful exit.",
       "            1: TL and TR have too close eigenvalues, so TL or",
       "               TR is perturbed to get a nonsingular equation.",
       "         NOTE: In the interests of speed, this routine does not",
       "               check the inputs for errors."]}},
 "zhbtrd"=>
  {"summary"=>
    ["ZHBTRD reduces a complex Hermitian band matrix A to real symmetric",
     "tridiagonal form T by a unitary similarity transformation:",
     "Q**H * A * Q = T."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  do not form Q;",
       "         = 'V':  form Q;",
       "         = 'U':  update a matrix X, by forming X*Q."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, the diagonal elements of AB are overwritten by the",
       "         diagonal elements of the tridiagonal matrix T; if KD > 0, the",
       "         elements on the first superdiagonal (if UPLO = 'U') or the",
       "         first subdiagonal (if UPLO = 'L') are overwritten by the",
       "         off-diagonal elements of T; the rest of AB is overwritten by",
       "         values generated during the reduction."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = T(i,i+1) if UPLO = 'U'; E(i) = T(i+1,i) if UPLO = 'L'."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,N)",
       "         On entry, if VECT = 'U', then Q must contain an N-by-N",
       "         matrix X; if VECT = 'N' or 'V', then Q need not be set.",
       "         On exit:",
       "         if VECT = 'V', Q contains the N-by-N unitary matrix Q;",
       "         if VECT = 'U', Q contains the product X*Q;",
       "         if VECT = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= 1, and LDQ >= N if VECT = 'V' or 'U'."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dladiv"=>
  {"summary"=>
    ["DLADIV performs complex division in  real arithmetic",
     "                      a + i*b",
     "           p + i*q = ---------",
     "                      c + i*d",
     "The algorithm is due to Michael Baudin and Robert L. Smith",
     "and can be found in the paper",
     "\"A Robust Complex Division in Scilab\""],
   "param"=>
    {"A"=>["[in]", "         A is DOUBLE PRECISION"],
     "B"=>["[in]", "         B is DOUBLE PRECISION"],
     "C"=>["[in]", "         C is DOUBLE PRECISION"],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION",
       "         The scalars a, b, c, and d in the above expression."],
     "P"=>["[out]", "         P is DOUBLE PRECISION"],
     "Q"=>
      ["[out]",
       "         Q is DOUBLE PRECISION",
       "         The scalars p and q in the above expression."]}},
 "clapmt"=>
  {"summary"=>
    ["CLAPMT rearranges the columns of the M by N matrix X as specified",
     "by the permutation K(1),K(2),...,K(N) of the integers 1,...,N.",
     "If FORWRD = .TRUE.,  forward permutation:",
     "     X(*,K(J)) is moved X(*,J) for J = 1,2,...,N.",
     "If FORWRD = .FALSE., backward permutation:",
     "     X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N."],
   "param"=>
    {"FORWRD"=>
      ["[in]",
       "         FORWRD is LOGICAL",
       "         = .TRUE., forward permutation",
       "         = .FALSE., backward permutation"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix X. N >= 0."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,N)",
       "         On entry, the M by N matrix X.",
       "         On exit, X contains the permuted matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X, LDX >= MAX(1,M)."],
     "K"=>
      ["[in,out]",
       "         K is INTEGER array, dimension (N)",
       "         On entry, K contains the permutation vector. K is used as",
       "         internal workspace, but reset to its original value on",
       "         output."]}},
 "sgeqlf"=>
  {"summary"=>
    ["SGEQLF computes a QL factorization of a real M-by-N matrix A:",
     "A = Q * L."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if m >= n, the lower triangle of the subarray",
       "         A(m-n+1:m,1:n) contains the N-by-N lower triangular matrix L;",
       "         if m <= n, the elements on and below the (n-m)-th",
       "         superdiagonal contain the M-by-N lower trapezoidal matrix L;",
       "         the remaining elements, with the array TAU, represent the",
       "         orthogonal matrix Q as a product of elementary reflectors",
       "         (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dptrfs"=>
  {"summary"=>
    ["DPTRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric positive definite",
     "and tridiagonal, and provides error bounds and backward error",
     "estimates for the solution."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix A."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the tridiagonal matrix A."],
     "DF"=>
      ["[in]",
       "         DF is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         factorization computed by DPTTRF."],
     "EF"=>
      ["[in]",
       "         EF is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the unit bidiagonal factor",
       "         L from the factorization computed by DPTTRF."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by DPTTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j)."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgemqr"=>
  {"summary"=>
    ["ZGEMQR overwrites the general real M-by-N matrix C with",
     "                     SIDE = 'L'     SIDE = 'R'",
     "     TRANS = 'N':      Q * C          C * Q",
     "     TRANS = 'T':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product",
     "of blocked elementary reflectors computed by tall skinny",
     "QR factorization (ZGEQR)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,K)",
       "         Part of the data structure to represent Q as returned by ZGEQR."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension (MAX(5,TSIZE)).",
       "         Part of the data structure to represent Q as returned by ZGEQR."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         The dimension of the array T. TSIZE >= 5."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "        (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed. The routine",
       "         only calculates the size of the WORK array, returns this",
       "         value as WORK(1), and no error message related to WORK ",
       "         is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zsycon"=>
  {"summary"=>
    ["ZSYCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex symmetric matrix A using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by ZSYTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cpbsv"=>
  {"summary"=>
    ["CPBSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite band matrix and X",
     "and B are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L * L**H,  if UPLO = 'L',",
     "where U is an upper triangular band matrix, and L is a lower",
     "triangular band matrix, with the same number of superdiagonals or",
     "subdiagonals as A.  The factored form of A is then used to solve the",
     "system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(KD+1+i-j,j) = A(i,j) for max(1,j-KD)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(N,j+KD).",
       "         See below for further details.",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H*U or A = L*L**H of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "ctprfs"=>
  {"summary"=>
    ["CTPRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular packed",
     "coefficient matrix.",
     "The solution matrix X must be computed by CTPTRS or some other",
     "means before entering this routine.  CTPRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cherfsx"=>
  {"summary"=>
    ["   CHERFSX improves the computed solution to a system of linear",
     "   equations when the coefficient matrix is Hermitian indefinite, and",
     "   provides error bounds and backward error estimates for the",
     "   solution.  In addition to normwise error bound, the code provides",
     "   maximum componentwise error bound if possible.  See comments for",
     "   ERR_BNDS_NORM and ERR_BNDS_COMP for details of the error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED and S",
     "   below. In this case, the solution and error bounds returned are",
     "   for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'Y':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(S) * A * diag(S).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "    upper triangular part of A contains the upper triangular",
       "    part of the matrix A, and the strictly lower triangular",
       "    part of A is not referenced.  If UPLO = 'L', the leading",
       "    N-by-N lower triangular part of A contains the lower",
       "    triangular part of the matrix A, and the strictly upper",
       "    triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The factored form of the matrix A.  AF contains the block",
       "    diagonal matrix D and the multipliers used to obtain the",
       "    factor U or L from the factorization A = U*D*U**T or A =",
       "    L*D*L**T as computed by SSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by SSYTRF."],
     "S"=>
      ["[in,out]",
       "         S is REAL array, dimension (N)",
       "    The scale factors for A.  If EQUED = 'Y', A is multiplied on",
       "    the left and right by diag(S).  S is an input argument if FACT =",
       "    'F'; otherwise, S is an output argument.  If FACT = 'F' and EQUED",
       "    = 'Y', each element of S must be positive.  If S is output, each",
       "    element of S is a power of the radix. If S is input, each element",
       "    of S should be a power of the radix to ensure a reliable solution",
       "    and error estimates. Scaling by powers of the radix does not cause",
       "    rounding errors unless the result underflows or overflows.",
       "    Rounding errors during scaling lead to refining with a matrix that",
       "    is not equivalent to the input matrix, producing error estimates",
       "    that may not be reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by SGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is REAL array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "dsyevx"=>
  {"summary"=>
    ["DSYEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A.  Eigenvalues and eigenvectors can be",
     "selected by specifying either a range of values or a range of indices",
     "for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= 1, when N <= 1;",
       "         otherwise 8*N.",
       "         For optimal efficiency, LWORK >= (NB+3)*N,",
       "         where NB is the max of the blocksize for DSYTRD and DORMTR",
       "         returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "dla_geamv"=>
  {"summary"=>
    ["DLA_GEAMV  performs one of the matrix-vector operations",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "   or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "m by n matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is INTEGER",
       "          On entry, TRANS specifies the operation to be performed as",
       "          follows:",
       "            BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)",
       "            BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "            BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of the matrix A.",
       "          M must be at least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array of DIMENSION ( LDA, n )",
       "          Before entry, the leading m by n part of the array A must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, m ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is DOUBLE PRECISION array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION",
       "          Array of DIMENSION at least",
       "          ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit.",
       " Level 2 Blas routine."]}},
 "dorml2"=>
  {"summary"=>
    ["DORML2 overwrites the general real m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**T* C  if SIDE = 'L' and TRANS = 'T', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**T if SIDE = 'R' and TRANS = 'T',",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by DGELQF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left",
       "         = 'R': apply Q or Q**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'T': apply Q**T (Transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGELQF in the first k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGELQF."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "slagtf"=>
  {"summary"=>
    ["SLAGTF factorizes the matrix (T - lambda*I), where T is an n by n",
     "tridiagonal matrix and lambda is a scalar, as",
     "   T - lambda*I = PLU,",
     "where P is a permutation matrix, L is a unit lower tridiagonal matrix",
     "with at most one non-zero sub-diagonal elements per column and U is",
     "an upper triangular matrix with at most two non-zero super-diagonal",
     "elements per column.",
     "The factorization is obtained by Gaussian elimination with partial",
     "pivoting and implicit row scaling.",
     "The parameter LAMBDA is included in the routine so that SLAGTF may",
     "be used, in conjunction with SLAGTS, to obtain eigenvectors of T by",
     "inverse iteration."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix T."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (N)",
       "         On entry, A must contain the diagonal elements of T.",
       "         On exit, A is overwritten by the n diagonal elements of the",
       "         upper triangular matrix U of the factorization of T."],
     "LAMBDA"=>
      ["[in]",
       "         LAMBDA is REAL",
       "         On entry, the scalar lambda."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (N-1)",
       "         On entry, B must contain the (n-1) super-diagonal elements of",
       "         T.",
       "         On exit, B is overwritten by the (n-1) super-diagonal",
       "         elements of the matrix U of the factorization of T."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (N-1)",
       "         On entry, C must contain the (n-1) sub-diagonal elements of",
       "         T.",
       "         On exit, C is overwritten by the (n-1) sub-diagonal elements",
       "         of the matrix L of the factorization of T."],
     "TOL"=>
      ["[in]",
       "         TOL is REAL",
       "         On entry, a relative tolerance used to indicate whether or",
       "         not the matrix (T - lambda*I) is nearly singular. TOL should",
       "         normally be chose as approximately the largest relative error",
       "         in the elements of T. For example, if the elements of T are",
       "         correct to about 4 significant figures, then TOL should be",
       "         set to about 5*10**(-4). If TOL is supplied as less than eps,",
       "         where eps is the relative machine precision, then the value",
       "         eps is used in place of TOL."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N-2)",
       "         On exit, D is overwritten by the (n-2) second super-diagonal",
       "         elements of the matrix U of the factorization of T."],
     "IN"=>
      ["[out]",
       "         IN is INTEGER array, dimension (N)",
       "         On exit, IN contains details of the permutation matrix P. If",
       "         an interchange occurred at the kth step of the elimination,",
       "         then IN(k) = 1, otherwise IN(k) = 0. The element IN(n)",
       "         returns the smallest positive integer j such that",
       "            abs( u(j,j) ).le. norm( (T - lambda*I)(j) )*TOL,",
       "         where norm( A(j) ) denotes the sum of the absolute values of",
       "         the jth row of the matrix A. If no such j exists then IN(n)",
       "         is returned as zero. If IN(n) is returned as positive, then a",
       "         diagonal element of U is small, indicating that",
       "         (T - lambda*I) is singular or nearly singular,"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0   : successful exit",
       "         .lt. 0: if INFO = -k, the kth argument had an illegal value"]}},
 "zgtcon"=>
  {"summary"=>
    ["ZGTCON estimates the reciprocal of the condition number of a complex",
     "tridiagonal matrix A using the LU factorization as computed by",
     "ZGTTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A as computed by ZGTTRF."],
     "D"=>
      ["[in]",
       "         D is COMPLEX*16 array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) elements of the first superdiagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is COMPLEX*16 array, dimension (N-2)",
       "         The (n-2) elements of the second superdiagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "spftri"=>
  {"summary"=>
    ["SPFTRI computes the inverse of a real (symmetric) positive definite",
     "matrix A using the Cholesky factorization A = U**T*U or A = L*L**T",
     "computed by SPFTRF."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'T':  The Transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension ( N*(N+1)/2 )",
       "         On entry, the symmetric matrix A in RFP format. RFP format is",
       "         described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'",
       "         then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'T' then RFP is",
       "         the transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the nt elements of",
       "         upper packed A. If UPLO = 'L' the RFP A contains the elements",
       "         of lower packed A. The LDA of RFP A is (N+1)/2 when TRANSR =",
       "         'T'. When TRANSR is 'N' the LDA is N+1 when N is even and N",
       "         is odd. See the Note below for more details.",
       "         On exit, the symmetric inverse of the original matrix, in the",
       "         same storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "ztpmqrt"=>
  {"summary"=>
    ["ZTPMQRT applies a complex orthogonal matrix Q obtained from a",
     "\"triangular-pentagonal\" complex block reflector H to a general",
     "complex matrix C, which consists of two blocks A and B."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size used for the storage of T.  K >= NB >= 1.",
       "         This must be the same value of NB used to generate T",
       "         in CTPQRT."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CTPQRT in B.  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDV >= max(1,M);",
       "         if SIDE = 'R', LDV >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by CTPQRT, stored as a NB-by-K matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension",
       "         (LDA,N) if SIDE = 'L' or",
       "         (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         Q*C or Q**H*C or C*Q or C*Q**H.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         Q*C or Q**H*C or C*Q or C*Q**H.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array. The dimension of WORK is",
       "          N*NB if SIDE = 'L', or  M*NB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgejsv"=>
  {"summary"=>
    ["CGEJSV computes the singular value decomposition (SVD) of a complex M-by-N",
     "matrix [A], where M >= N. The SVD of [A] is written as",
     "             [A] = [U] * [SIGMA] * [V]^*,",
     "where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N",
     "diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and",
     "[V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are",
     "the singular values of [A]. The columns of [U] and [V] are the left and",
     "the right singular vectors of [A], respectively. The matrices [U] and [V]",
     "are computed and stored in the arrays U and V, respectively. The diagonal",
     "of [SIGMA] is computed and stored in the array SVA."],
   "param"=>
    {"JOBA"=>
      ["[in]",
       "         JOBA is CHARACTER*1",
       "        Specifies the level of accuracy:",
       "      = 'C': This option works well (high relative accuracy) if A = B * D,",
       "             with well-conditioned B and arbitrary diagonal matrix D.",
       "             The accuracy cannot be spoiled by COLUMN scaling. The",
       "             accuracy of the computed output depends on the condition of",
       "             B, and the procedure aims at the best theoretical accuracy.",
       "             The relative error max_{i=1:N}|d sigma_i| / sigma_i is",
       "             bounded by f(M,N)*epsilon* cond(B), independent of D.",
       "             The input matrix is preprocessed with the QRF with column",
       "             pivoting. This initial preprocessing and preconditioning by",
       "             a rank revealing QR factorization is common for all values of",
       "             JOBA. Additional actions are specified as follows:",
       "      = 'E': Computation as with 'C' with an additional estimate of the",
       "             condition number of B. It provides a realistic error bound.",
       "      = 'F': If A = D1 * C * D2 with ill-conditioned diagonal scalings",
       "             D1, D2, and well-conditioned matrix C, this option gives",
       "             higher accuracy than the 'C' option. If the structure of the",
       "             input matrix is not known, and relative accuracy is",
       "             desirable, then this option is advisable. The input matrix A",
       "             is preprocessed with QR factorization with FULL (row and",
       "             column) pivoting.",
       "      = 'G'  Computation as with 'F' with an additional estimate of the",
       "             condition number of B, where A=B*D. If A has heavily weighted",
       "             rows, then using this condition number gives too pessimistic",
       "             error bound.",
       "      = 'A': Small singular values are not well determined by the data ",
       "             and are considered as noisy; the matrix is treated as",
       "             numerically rank defficient. The error in the computed",
       "             singular values is bounded by f(m,n)*epsilon*||A||.",
       "             The computed SVD A = U * S * V^* restores A up to",
       "             f(m,n)*epsilon*||A||.",
       "             This gives the procedure the licence to discard (set to zero)",
       "             all singular values below N*epsilon*||A||.",
       "      = 'R': Similar as in 'A'. Rank revealing property of the initial",
       "             QR factorization is used do reveal (using triangular factor)",
       "             a gap sigma_{r+1} < epsilon * sigma_r in which case the",
       "             numerical RANK is declared to be r. The SVD is computed with",
       "             absolute error bounds, but more accurately than with 'A'."],
     "JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "        Specifies whether to compute the columns of U:",
       "      = 'U': N columns of U are returned in the array U.",
       "      = 'F': full set of M left sing. vectors is returned in the array U.",
       "      = 'W': U may be used as workspace of length M*N. See the description",
       "             of U.",
       "      = 'N': U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "        Specifies whether to compute the matrix V:",
       "      = 'V': N columns of V are returned in the array V; Jacobi rotations",
       "             are not explicitly accumulated.",
       "      = 'J': N columns of V are returned in the array V, but they are",
       "             computed as the product of Jacobi rotations, if JOBT .EQ. 'N'.",
       "      = 'W': V may be used as workspace of length N*N. See the description",
       "             of V.",
       "      = 'N': V is not computed."],
     "JOBR"=>
      ["[in]",
       "         JOBR is CHARACTER*1",
       "        Specifies the RANGE for the singular values. Issues the licence to",
       "        set to zero small positive singular values if they are outside",
       "        specified range. If A .NE. 0 is scaled so that the largest singular",
       "        value of c*A is around SQRT(BIG), BIG=SLAMCH('O'), then JOBR issues",
       "        the licence to kill columns of A whose norm in c*A is less than",
       "        SQRT(SFMIN) (for JOBR.EQ.'R'), or less than SMALL=SFMIN/EPSLN,",
       "        where SFMIN=SLAMCH('S'), EPSLN=SLAMCH('E').",
       "      = 'N': Do not kill small columns of c*A. This option assumes that",
       "             BLAS and QR factorizations and triangular solvers are",
       "             implemented to work in that range. If the condition of A",
       "             is greater than BIG, use CGESVJ.",
       "      = 'R': RESTRICTED range for sigma(c*A) is [SQRT(SFMIN), SQRT(BIG)]",
       "             (roughly, as described above). This option is recommended.",
       "                                            ===========================",
       "        For computing the singular values in the FULL range [SFMIN,BIG]",
       "        use CGESVJ."],
     "JOBT"=>
      ["[in]",
       "         JOBT is CHARACTER*1",
       "        If the matrix is square then the procedure may determine to use",
       "        transposed A if A^* seems to be better with respect to convergence.",
       "        If the matrix is not square, JOBT is ignored.",
       "        The decision is based on two values of entropy over the adjoint",
       "        orbit of A^* * A. See the descriptions of WORK(6) and WORK(7).",
       "      = 'T': transpose if entropy test indicates possibly faster",
       "        convergence of Jacobi process if A^* is taken as input. If A is",
       "        replaced with A^*, then the row pivoting is included automatically.",
       "      = 'N': do not speculate.",
       "        The option 'T' can be used to compute only the singular values, or",
       "        the full SVD (U, SIGMA and V). For only one set of singular vectors",
       "        (U or V), the caller should provide both U and V, as one of the",
       "        matrices is used as workspace if the matrix A is transposed.",
       "        The implementer can easily remove this constraint and make the",
       "        code more complicated. See the descriptions of U and V.",
       "        In general, this option is considered experimental, and 'N'; should",
       "        be preferred. This is subject to changes in the future."],
     "JOBP"=>
      ["[in]",
       "         JOBP is CHARACTER*1",
       "        Issues the licence to introduce structured perturbations to drown",
       "        denormalized numbers. This licence should be active if the",
       "        denormals are poorly implemented, causing slow computation,",
       "        especially in cases of fast convergence (!). For details see [1,2].",
       "        For the sake of simplicity, this perturbations are included only",
       "        when the full SVD or only the singular values are requested. The",
       "        implementer/user can easily add the perturbation for the cases of",
       "        computing one set of singular vectors.",
       "      = 'P': introduce perturbation",
       "      = 'N': do not perturb"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "        The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The number of columns of the input matrix A. M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "SVA"=>
      ["[out]",
       "         SVA is REAL array, dimension (N)",
       "         On exit,",
       "         - For WORK(1)/WORK(2) = ONE: The singular values of A. During the",
       "           computation SVA contains Euclidean column norms of the",
       "           iterated matrices in the array A.",
       "         - For WORK(1) .NE. WORK(2): The singular values of A are",
       "           (WORK(1)/WORK(2)) * SVA(1:N). This factored form is used if",
       "           sigma_max(A) overflows or if small singular values have been",
       "           saved from underflow by scaling the input matrix A.",
       "         - If JOBR='R' then some of the singular values may be returned",
       "           as exact zeros obtained by \"set to zero\" because they are",
       "           below the numerical rank threshold or are denormalized numbers."],
     "U"=>
      ["[out]",
       "         U is COMPLEX array, dimension ( LDU, N ) or ( LDU, M )",
       "         If JOBU = 'U', then U contains on exit the M-by-N matrix of",
       "                        the left singular vectors.",
       "         If JOBU = 'F', then U contains on exit the M-by-M matrix of",
       "                        the left singular vectors, including an ONB",
       "                        of the orthogonal complement of the Range(A).",
       "         If JOBU = 'W'  .AND. (JOBV.EQ.'V' .AND. JOBT.EQ.'T' .AND. M.EQ.N),",
       "                        then U is used as workspace if the procedure",
       "                        replaces A with A^*. In that case, [V] is computed",
       "                        in U as left singular vectors of A^* and then",
       "                        copied back to the V array. This 'W' option is just",
       "                        a reminder to the caller that in this case U is",
       "                        reserved as workspace of length N*N.",
       "         If JOBU = 'N'  U is not referenced, unless JOBT='T'."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U,  LDU >= 1.",
       "         IF  JOBU = 'U' or 'F' or 'W',  then LDU >= M."],
     "V"=>
      ["[out]",
       "         V is COMPLEX array, dimension ( LDV, N )",
       "         If JOBV = 'V', 'J' then V contains on exit the N-by-N matrix of",
       "                        the right singular vectors;",
       "         If JOBV = 'W', AND (JOBU.EQ.'U' AND JOBT.EQ.'T' AND M.EQ.N),",
       "                        then V is used as workspace if the pprocedure",
       "                        replaces A with A^*. In that case, [U] is computed",
       "                        in V as right singular vectors of A^* and then",
       "                        copied back to the U array. This 'W' option is just",
       "                        a reminder to the caller that in this case V is",
       "                        reserved as workspace of length N*N.",
       "         If JOBV = 'N'  V is not referenced, unless JOBT='T'."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V' or 'J' or 'W', then LDV >= N."],
     "CWORK"=>
      ["[out]",
       "         CWORK is COMPLEX array, dimension (MAX(2,LWORK))",
       "         If the call to CGEJSV is a workspace query (indicated by LWORK=-1 or",
       "         LRWORK=-1), then on exit CWORK(1) contains the required length of ",
       "         CWORK for the job parameters used in the call."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         Length of CWORK to confirm proper allocation of workspace.",
       "         LWORK depends on the job:",
       "         1. If only SIGMA is needed ( JOBU.EQ.'N', JOBV.EQ.'N' ) and",
       "           1.1 .. no scaled condition estimate required (JOBA.NE.'E'.AND.JOBA.NE.'G'):",
       "              LWORK >= 2*N+1. This is the minimal requirement.",
       "              ->> For optimal performance (blocked code) the optimal value",
       "              is LWORK >= N + (N+1)*NB. Here NB is the optimal",
       "              block size for CGEQP3 and CGEQRF.",
       "              In general, optimal LWORK is computed as",
       "              LWORK >= max(N+LWORK(CGEQP3),N+LWORK(CGEQRF), LWORK(CGESVJ)).        ",
       "           1.2. .. an estimate of the scaled condition number of A is",
       "              required (JOBA='E', or 'G'). In this case, LWORK the minimal",
       "              requirement is LWORK >= N*N + 2*N.",
       "              ->> For optimal performance (blocked code) the optimal value",
       "              is LWORK >= max(N+(N+1)*NB, N*N+2*N)=N**2+2*N.",
       "              In general, the optimal length LWORK is computed as",
       "              LWORK >= max(N+LWORK(CGEQP3),N+LWORK(CGEQRF), LWORK(CGESVJ),",
       "                           N*N+LWORK(CPOCON)).",
       "         2. If SIGMA and the right singular vectors are needed (JOBV.EQ.'V'),",
       "            (JOBU.EQ.'N')",
       "           2.1   .. no scaled condition estimate requested (JOBE.EQ.'N'):    ",
       "           -> the minimal requirement is LWORK >= 3*N.",
       "           -> For optimal performance, ",
       "              LWORK >= max(N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,",
       "              where NB is the optimal block size for CGEQP3, CGEQRF, CGELQ,",
       "              CUNMLQ. In general, the optimal length LWORK is computed as",
       "              LWORK >= max(N+LWORK(CGEQP3), N+LWORK(CGESVJ),",
       "                      N+LWORK(CGELQF), 2*N+LWORK(CGEQRF), N+LWORK(CUNMLQ)).",
       "           2.2 .. an estimate of the scaled condition number of A is",
       "              required (JOBA='E', or 'G').",
       "           -> the minimal requirement is LWORK >= 3*N.      ",
       "           -> For optimal performance, ",
       "              LWORK >= max(N+(N+1)*NB, 2*N,2*N+N*NB)=2*N+N*NB,",
       "              where NB is the optimal block size for CGEQP3, CGEQRF, CGELQ,",
       "              CUNMLQ. In general, the optimal length LWORK is computed as",
       "              LWORK >= max(N+LWORK(CGEQP3), LWORK(CPOCON), N+LWORK(CGESVJ),",
       "                      N+LWORK(CGELQF), 2*N+LWORK(CGEQRF), N+LWORK(CUNMLQ)).   ",
       "         3. If SIGMA and the left singular vectors are needed",
       "           3.1  .. no scaled condition estimate requested (JOBE.EQ.'N'):",
       "           -> the minimal requirement is LWORK >= 3*N.",
       "           -> For optimal performance:",
       "              if JOBU.EQ.'U' :: LWORK >= max(3*N, N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,",
       "              where NB is the optimal block size for CGEQP3, CGEQRF, CUNMQR.",
       "              In general, the optimal length LWORK is computed as",
       "              LWORK >= max(N+LWORK(CGEQP3), 2*N+LWORK(CGEQRF), N+LWORK(CUNMQR)). ",
       "           3.2  .. an estimate of the scaled condition number of A is",
       "              required (JOBA='E', or 'G').",
       "           -> the minimal requirement is LWORK >= 3*N.",
       "           -> For optimal performance:",
       "              if JOBU.EQ.'U' :: LWORK >= max(3*N, N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,",
       "              where NB is the optimal block size for CGEQP3, CGEQRF, CUNMQR.",
       "              In general, the optimal length LWORK is computed as",
       "              LWORK >= max(N+LWORK(CGEQP3),N+LWORK(CPOCON),",
       "                       2*N+LWORK(CGEQRF), N+LWORK(CUNMQR)).",
       "         4. If the full SVD is needed: (JOBU.EQ.'U' or JOBU.EQ.'F') and",
       "           4.1. if JOBV.EQ.'V'",
       "              the minimal requirement is LWORK >= 5*N+2*N*N.",
       "           4.2. if JOBV.EQ.'J' the minimal requirement is",
       "              LWORK >= 4*N+N*N.",
       "           In both cases, the allocated CWORK can accommodate blocked runs",
       "           of CGEQP3, CGEQRF, CGELQF, CUNMQR, CUNMLQ.",
       "",
       "         If the call to CGEJSV is a workspace query (indicated by LWORK=-1 or",
       "         LRWORK=-1), then on exit CWORK(1) contains the optimal and CWORK(2) contains the",
       "         minimal length of CWORK for the job parameters used in the call.        "],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(7,LWORK))",
       "         On exit,",
       "         RWORK(1) = Determines the scaling factor SCALE = RWORK(2) / RWORK(1)",
       "                   such that SCALE*SVA(1:N) are the computed singular values",
       "                   of A. (See the description of SVA().)",
       "         RWORK(2) = See the description of RWORK(1).",
       "         RWORK(3) = SCONDA is an estimate for the condition number of",
       "                   column equilibrated A. (If JOBA .EQ. 'E' or 'G')",
       "                   SCONDA is an estimate of SQRT(||(R^* * R)^(-1)||_1).",
       "                   It is computed using SPOCON. It holds",
       "                   N^(-1/4) * SCONDA <= ||R^(-1)||_2 <= N^(1/4) * SCONDA",
       "                   where R is the triangular factor from the QRF of A.",
       "                   However, if R is truncated and the numerical rank is",
       "                   determined to be strictly smaller than N, SCONDA is",
       "                   returned as -1, thus indicating that the smallest",
       "                   singular values might be lost.",
       "         If full SVD is needed, the following two condition numbers are",
       "         useful for the analysis of the algorithm. They are provied for",
       "         a developer/implementer who is familiar with the details of",
       "         the method.",
       "         RWORK(4) = an estimate of the scaled condition number of the",
       "                   triangular factor in the first QR factorization.",
       "         RWORK(5) = an estimate of the scaled condition number of the",
       "                   triangular factor in the second QR factorization.",
       "         The following two parameters are computed if JOBT .EQ. 'T'.",
       "         They are provided for a developer/implementer who is familiar",
       "         with the details of the method.",
       "         RWORK(6) = the entropy of A^* * A :: this is the Shannon entropy",
       "                   of diag(A^* * A) / Trace(A^* * A) taken as point in the",
       "                   probability simplex.",
       "         RWORK(7) = the entropy of A * A^*. (See the description of RWORK(6).)",
       "         If the call to CGEJSV is a workspace query (indicated by LWORK=-1 or",
       "         LRWORK=-1), then on exit RWORK(1) contains the required length of",
       "         RWORK for the job parameters used in the call."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         Length of RWORK to confirm proper allocation of workspace.",
       "         LRWORK depends on the job:",
       "      1. If only the singular values are requested i.e. if",
       "         LSAME(JOBU,'N') .AND. LSAME(JOBV,'N')",
       "         then:",
       "         1.1. If LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G'),",
       "              then: LRWORK = max( 7, 2 * M ).",
       "         1.2. Otherwise, LRWORK  = max( 7,  N ).",
       "      2. If singular values with the right singular vectors are requested",
       "         i.e. if",
       "         (LSAME(JOBV,'V').OR.LSAME(JOBV,'J')) .AND.",
       "         .NOT.(LSAME(JOBU,'U').OR.LSAME(JOBU,'F'))",
       "         then:",
       "         2.1. If LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G'),",
       "         then LRWORK = max( 7, 2 * M ).",
       "         2.2. Otherwise, LRWORK  = max( 7,  N ).",
       "      3. If singular values with the left singular vectors are requested, i.e. if",
       "         (LSAME(JOBU,'U').OR.LSAME(JOBU,'F')) .AND.",
       "         .NOT.(LSAME(JOBV,'V').OR.LSAME(JOBV,'J'))",
       "         then:",
       "         3.1. If LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G'),",
       "         then LRWORK = max( 7, 2 * M ).",
       "         3.2. Otherwise, LRWORK  = max( 7,  N ).",
       "      4. If singular values with both the left and the right singular vectors",
       "         are requested, i.e. if",
       "         (LSAME(JOBU,'U').OR.LSAME(JOBU,'F')) .AND.",
       "         (LSAME(JOBV,'V').OR.LSAME(JOBV,'J'))",
       "         then:",
       "         4.1. If LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G'),",
       "         then LRWORK = max( 7, 2 * M ).",
       "         4.2. Otherwise, LRWORK  = max( 7, N ).",
       "",
       "         If, on entry, LRWORK = -1 ot LWORK=-1, a workspace query is assumed and ",
       "         the length of RWORK is returned in RWORK(1). "],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, of dimension at least 4, that further depends",
       "         on the job:",
       "",
       "         1. If only the singular values are requested then:",
       "            If ( LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G') ) ",
       "            then the length of IWORK is N+M; otherwise the length of IWORK is N.",
       "         2. If the singular values and the right singular vectors are requested then:",
       "            If ( LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G') ) ",
       "            then the length of IWORK is N+M; otherwise the length of IWORK is N. ",
       "         3. If the singular values and the left singular vectors are requested then:",
       "            If ( LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G') ) ",
       "            then the length of IWORK is N+M; otherwise the length of IWORK is N. ",
       "         4. If the singular values with both the left and the right singular vectors",
       "            are requested, then:      ",
       "            4.1. If LSAME(JOBV,'J') the length of IWORK is determined as follows:",
       "                 If ( LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G') ) ",
       "                 then the length of IWORK is N+M; otherwise the length of IWORK is N. ",
       "            4.2. If LSAME(JOBV,'V') the length of IWORK is determined as follows:",
       "                 If ( LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G') ) ",
       "                 then the length of IWORK is 2*N+M; otherwise the length of IWORK is 2*N.",
       "       ",
       "         On exit,",
       "         IWORK(1) = the numerical rank determined after the initial",
       "                    QR factorization with pivoting. See the descriptions",
       "                    of JOBA and JOBR.",
       "         IWORK(2) = the number of the computed nonzero singular values",
       "         IWORK(3) = if nonzero, a warning message:",
       "                    If IWORK(3).EQ.1 then some of the column norms of A",
       "                    were denormalized floats. The requested high accuracy",
       "                    is not warranted by the data.",
       "         IWORK(4) = 1 or -1. If IWORK(4) .EQ. 1, then the procedure used A^* to",
       "                    do the job as specified by the JOB parameters.",
       "         If the call to CGEJSV is a workspace query (indicated by LWORK .EQ. -1 and ",
       "         LRWORK .EQ. -1), then on exit IWORK(1) contains the required length of ",
       "         IWORK for the job parameters used in the call."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          < 0  : if INFO = -i, then the i-th argument had an illegal value.",
       "          = 0 :  successful exit;",
       "          > 0 :  CGEJSV  did not converge in the maximal allowed number",
       "                 of sweeps. The computed values may be inaccurate."]}},
 "stgevc"=>
  {"summary"=>
    ["STGEVC computes some or all of the right and/or left eigenvectors of",
     "a pair of real matrices (S,P), where S is a quasi-triangular matrix",
     "and P is upper triangular.  Matrix pairs of this type are produced by",
     "the generalized Schur factorization of a matrix pair (A,B):",
     "   A = Q*S*Z**T,  B = Q*P*Z**T",
     "as computed by SGGHRD + SHGEQZ.",
     "The right eigenvector x and the left eigenvector y of (S,P)",
     "corresponding to an eigenvalue w are defined by:",
     "   S*x = w*P*x,  (y**H)*S = w*(y**H)*P,",
     "where y**H denotes the conjugate tranpose of y.",
     "The eigenvalues are not input to this routine, but are computed",
     "directly from the diagonal blocks of S and P.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of (S,P), or the products Z*X and/or Q*Y,",
     "where Z and Q are input matrices.",
     "If Q and Z are the orthogonal factors from the generalized Schur",
     "factorization of a matrix pair (A,B), then Z*X and Q*Y",
     "are the matrices of right and left eigenvectors of (A,B)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R': compute right eigenvectors only;",
       "         = 'L': compute left eigenvectors only;",
       "         = 'B': compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute all right and/or left eigenvectors;",
       "         = 'B': compute all right and/or left eigenvectors,",
       "                backtransformed by the matrices in VR and/or VL;",
       "         = 'S': compute selected right and/or left eigenvectors,",
       "                specified by the logical array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY='S', SELECT specifies the eigenvectors to be",
       "         computed.  If w(j) is a real eigenvalue, the corresponding",
       "         real eigenvector is computed if SELECT(j) is .TRUE..",
       "         If w(j) and w(j+1) are the real and imaginary parts of a",
       "         complex eigenvalue, the corresponding complex eigenvector",
       "         is computed if either SELECT(j) or SELECT(j+1) is .TRUE.,",
       "         and on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is",
       "         set to .FALSE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices S and P.  N >= 0."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension (LDS,N)",
       "         The upper quasi-triangular matrix S from a generalized Schur",
       "         factorization, as computed by SHGEQZ."],
     "LDS"=>
      ["[in]",
       "         LDS is INTEGER",
       "         The leading dimension of array S.  LDS >= max(1,N)."],
     "P"=>
      ["[in]",
       "         P is REAL array, dimension (LDP,N)",
       "         The upper triangular matrix P from a generalized Schur",
       "         factorization, as computed by SHGEQZ.",
       "         2-by-2 diagonal blocks of P corresponding to 2-by-2 blocks",
       "         of S must be in positive diagonal form."],
     "LDP"=>
      ["[in]",
       "         LDP is INTEGER",
       "         The leading dimension of array P.  LDP >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is REAL array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the orthogonal matrix Q",
       "         of left Schur vectors returned by SHGEQZ).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of (S,P);",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of (S,P) specified by",
       "                     SELECT, stored consecutively in the columns of",
       "                     VL, in the same order as their eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part, and the second the imaginary part.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of array VL.  LDVL >= 1, and if",
       "         SIDE = 'L' or 'B', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is REAL array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Z (usually the orthogonal matrix Z",
       "         of right Schur vectors returned by SHGEQZ).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of (S,P);",
       "         if HOWMNY = 'B' or 'b', the matrix Z*X;",
       "         if HOWMNY = 'S' or 's', the right eigenvectors of (S,P)",
       "                     specified by SELECT, stored consecutively in the",
       "                     columns of VR, in the same order as their",
       "                     eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part and the second the imaginary part.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1, and if",
       "         SIDE = 'R' or 'B', LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.  If HOWMNY = 'A' or 'B', M",
       "         is set to N.  Each selected real eigenvector occupies one",
       "         column and each selected complex eigenvector occupies two",
       "         columns."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (6*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  the 2-by-2 block (INFO:INFO+1) does not have a complex",
       "               eigenvalue."]}},
 "slaqsp"=>
  {"summary"=>
    ["SLAQSP equilibrates a symmetric matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the equilibrated matrix:  diag(S) * A * diag(S), in",
       "         the same storage format as A."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is REAL",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "zggbal"=>
  {"summary"=>
    ["ZGGBAL balances a pair of general complex matrices (A,B).  This",
     "involves, first, permuting A and B by similarity transformations to",
     "isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N",
     "elements on the diagonal; and second, applying a diagonal similarity",
     "transformation to rows and columns ILO to IHI to make the rows",
     "and columns as close in norm as possible. Both steps are optional.",
     "Balancing may reduce the 1-norm of the matrices, and improve the",
     "accuracy of the computed eigenvalues and/or eigenvectors in the",
     "generalized eigenvalue problem A*x = lambda*B*x."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the operations to be performed on A and B:",
       "         = 'N':  none:  simply set ILO = 1, IHI = N, LSCALE(I) = 1.0",
       "                 and RSCALE(I) = 1.0 for i=1,...,N;",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the input matrix A.",
       "         On exit, A is overwritten by the balanced matrix.",
       "         If JOB = 'N', A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the input matrix B.",
       "         On exit, B is overwritten by the balanced matrix.",
       "         If JOB = 'N', B is not referenced."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are set to integers such that on exit",
       "         A(i,j) = 0 and B(i,j) = 0 if i > j and",
       "         j = 1,...,ILO-1 or i = IHI+1,...,N.",
       "         If JOB = 'N' or 'S', ILO = 1 and IHI = N."],
     "LSCALE"=>
      ["[out]",
       "         LSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the left side of A and B.  If P(j) is the index of the",
       "         row interchanged with row j, and D(j) is the scaling factor",
       "         applied to row j, then",
       "           LSCALE(j) = P(j)    for J = 1,...,ILO-1",
       "                     = D(j)    for J = ILO,...,IHI",
       "                     = P(j)    for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "RSCALE"=>
      ["[out]",
       "         RSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the right side of A and B.  If P(j) is the index of the",
       "         column interchanged with column j, and D(j) is the scaling",
       "         factor applied to column j, then",
       "           RSCALE(j) = P(j)    for J = 1,...,ILO-1",
       "                     = D(j)    for J = ILO,...,IHI",
       "                     = P(j)    for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (lwork)",
       "         lwork must be at least max(1,6*N) when JOB = 'S' or 'B', and",
       "         at least 1 when JOB = 'N' or 'P'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dlahqr"=>
  {"summary"=>
    ["   DLAHQR is an auxiliary routine called by DHSEQR to update the",
     "   eigenvalues and Schur decomposition already computed by DHSEQR, by",
     "   dealing with the Hessenberg submatrix in rows and columns ILO to",
     "   IHI."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that H is already upper quasi-triangular in",
       "         rows and columns IHI+1:N, and that H(ILO,ILO-1) = 0 (unless",
       "         ILO = 1). DLAHQR works primarily with the Hessenberg",
       "         submatrix in rows and columns ILO to IHI, but applies",
       "         transformations to all of H if WANTT is .TRUE..",
       "         1 <= ILO <= max(1,IHI); IHI <= N."],
     "H"=>
      ["[in,out]",
       "         H is DOUBLE PRECISION array, dimension (LDH,N)",
       "         On entry, the upper Hessenberg matrix H.",
       "         On exit, if INFO is zero and if WANTT is .TRUE., H is upper",
       "         quasi-triangular in rows and columns ILO:IHI, with any",
       "         2-by-2 diagonal blocks in standard form. If INFO is zero",
       "         and WANTT is .FALSE., the contents of H are unspecified on",
       "         exit.  The output state of H if INFO is nonzero is given",
       "         below under the description of INFO."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H. LDH >= max(1,N)."],
     "WR"=>["[out]", "         WR is DOUBLE PRECISION array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is DOUBLE PRECISION array, dimension (N)",
       "         The real and imaginary parts, respectively, of the computed",
       "         eigenvalues ILO to IHI are stored in the corresponding",
       "         elements of WR and WI. If two eigenvalues are computed as a",
       "         complex conjugate pair, they are stored in consecutive",
       "         elements of WR and WI, say the i-th and (i+1)th, with",
       "         WI(i) > 0 and WI(i+1) < 0. If WANTT is .TRUE., the",
       "         eigenvalues are stored in the same order as on the diagonal",
       "         of the Schur form returned in H, with WR(i) = H(i,i), and, if",
       "         H(i:i+1,i:i+1) is a 2-by-2 diagonal block,",
       "         WI(i) = sqrt(H(i+1,i)*H(i,i+1)) and WI(i+1) = -WI(i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE..",
       "         1 <= ILOZ <= ILO; IHI <= IHIZ <= N."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ,N)",
       "         If WANTZ is .TRUE., on entry Z must contain the current",
       "         matrix Z of transformations accumulated by DHSEQR, and on",
       "         exit Z has been updated; transformations are applied only to",
       "         the submatrix Z(ILOZ:IHIZ,ILO:IHI).",
       "         If WANTZ is .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          =   0: successful exit",
       "         .GT. 0: If INFO = i, DLAHQR failed to compute all the",
       "                 eigenvalues ILO to IHI in a total of 30 iterations",
       "                 per eigenvalue; elements i+1:ihi of WR and WI",
       "                 contain those eigenvalues which have been",
       "                 successfully computed.",
       "                 If INFO .GT. 0 and WANTT is .FALSE., then on exit,",
       "                 the remaining unconverged eigenvalues are the",
       "                 eigenvalues of the upper Hessenberg matrix rows",
       "                 and columns ILO thorugh INFO of the final, output",
       "                 value of H.",
       "                 If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "         (*)       (initial value of H)*U  = U*(final value of H)",
       "                 where U is an orthognal matrix.    The final",
       "                 value of H is upper Hessenberg and triangular in",
       "                 rows and columns INFO+1 through IHI.",
       "                 If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                     (final value of Z)  = (initial value of Z)*U",
       "                 where U is the orthogonal matrix in (*)",
       "                 (regardless of the value of WANTT.)"]}},
 "dpbequ"=>
  {"summary"=>
    ["DPBEQU computes row and column scalings intended to equilibrate a",
     "symmetric positive definite band matrix A and reduce its condition",
     "number (with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular of A is stored;",
       "         = 'L':  Lower triangular of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The upper or lower triangle of the symmetric band matrix A,",
       "         stored in the first KD+1 rows of the array.  The j-th column",
       "         of A is stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A.  LDAB >= KD+1."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is DOUBLE PRECISION",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "dlaln2"=>
  {"summary"=>
    ["DLALN2 solves a system of the form  (ca A - w D ) X = s B",
     "or (ca A**T - w D) X = s B   with possible scaling (\"s\") and",
     "perturbation of A.  (A**T means A-transpose.)",
     "A is an NA x NA real matrix, ca is a real scalar, D is an NA x NA",
     "real diagonal matrix, w is a real or complex value, and X and B are",
     "NA x 1 matrices -- real if w is real, complex if w is complex.  NA",
     "may be 1 or 2.",
     "If w is complex, X and B are represented as NA x 2 matrices,",
     "the first column of each being the real part and the second",
     "being the imaginary part.",
     "\"s\" is a scaling factor (.LE. 1), computed by DLALN2, which is",
     "so chosen that X can be computed without overflow.  X is further",
     "scaled if necessary to assure that norm(ca A - w D)*norm(X) is less",
     "than overflow.",
     "If both singular values of (ca A - w D) are less than SMIN,",
     "SMIN*identity will be used instead of (ca A - w D).  If only one",
     "singular value is less than SMIN, one element of (ca A - w D) will be",
     "perturbed enough to make the smallest singular value roughly SMIN.",
     "If both singular values are at least SMIN, (ca A - w D) will not be",
     "perturbed.  In any case, the perturbation will be at most some small",
     "multiple of max( SMIN, ulp*norm(ca A - w D) ).  The singular values",
     "are computed by infinity-norm approximations, and thus will only be",
     "correct to a factor of 2 or so.",
     "Note: all input quantities are assumed to be smaller than overflow",
     "by a reasonable factor.  (See BIGNUM.)"],
   "param"=>
    {"LTRANS"=>
      ["[in]",
       "         LTRANS is LOGICAL",
       "         =.TRUE.:  A-transpose will be used.",
       "         =.FALSE.: A will be used (not transposed.)"],
     "NA"=>
      ["[in]",
       "         NA is INTEGER",
       "         The size of the matrix A.  It may (only) be 1 or 2."],
     "NW"=>
      ["[in]",
       "         NW is INTEGER",
       "         1 if \"w\" is real, 2 if \"w\" is complex.  It may only be 1",
       "         or 2."],
     "SMIN"=>
      ["[in]",
       "         SMIN is DOUBLE PRECISION",
       "         The desired lower bound on the singular values of A.  This",
       "         should be a safe distance away from underflow or overflow,",
       "         say, between (underflow/machine precision) and  (machine",
       "         precision * overflow ).  (See BIGNUM and ULP.)"],
     "CA"=>
      ["[in]",
       "         CA is DOUBLE PRECISION",
       "         The coefficient c, which A is multiplied by."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,NA)",
       "         The NA x NA matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  It must be at least NA."],
     "D1"=>
      ["[in]",
       "         D1 is DOUBLE PRECISION",
       "         The 1,1 element in the diagonal matrix D."],
     "D2"=>
      ["[in]",
       "         D2 is DOUBLE PRECISION",
       "         The 2,2 element in the diagonal matrix D.  Not used if NA=1."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NW)",
       "         The NA x NW matrix B (right-hand side).  If NW=2 (\"w\" is",
       "         complex), column 1 contains the real part of B and column 2",
       "         contains the imaginary part."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  It must be at least NA."],
     "WR"=>
      ["[in]",
       "         WR is DOUBLE PRECISION",
       "         The real part of the scalar \"w\"."],
     "WI"=>
      ["[in]",
       "         WI is DOUBLE PRECISION",
       "         The imaginary part of the scalar \"w\".  Not used if NW=1."],
     "X"=>
      ["[out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NW)",
       "         The NA x NW matrix X (unknowns), as computed by DLALN2.",
       "         If NW=2 (\"w\" is complex), on exit, column 1 will contain",
       "         the real part of X and column 2 will contain the imaginary",
       "         part."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of X.  It must be at least NA."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         The scale factor that B must be multiplied by to insure",
       "         that overflow does not occur when computing X.  Thus,",
       "         (ca A - w D) X  will be SCALE*B, not B (ignoring",
       "         perturbations of A.)  It will be at most 1."],
     "XNORM"=>
      ["[out]",
       "         XNORM is DOUBLE PRECISION",
       "         The infinity-norm of X, when X is regarded as an NA x NW",
       "         real matrix."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         An error flag.  It will be set to zero if no error occurs,",
       "         a negative number if an argument is in error, or a positive",
       "         number if  ca A - w D  had to be perturbed.",
       "         The possible values are:",
       "         = 0: No error occurred, and (ca A - w D) did not have to be",
       "                perturbed.",
       "         = 1: (ca A - w D) had to be perturbed to make its smallest",
       "              (or only) singular value greater than SMIN.",
       "         NOTE: In the interests of speed, this routine does not",
       "               check the inputs for errors."]}},
 "dgelqt3"=>
  {"summary"=>
    ["DGELQT3 recursively computes a LQ factorization of a real M-by-N",
     "matrix A, using the compact WY representation of Q.",
     "Based on the algorithm of Elmroth and Gustavson,",
     "IBM J. Res. Develop. Vol 44 No. 4 July 2000."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M =< N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the real M-by-N matrix A.  On exit, the elements on and",
       "         below the diagonal contain the N-by-N lower triangular matrix L; the",
       "         elements above the diagonal are the rows of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dggqrf"=>
  {"summary"=>
    ["DGGQRF computes a generalized QR factorization of an N-by-M matrix A",
     "and an N-by-P matrix B:",
     "            A = Q*R,        B = Q*T*Z,",
     "where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal",
     "matrix, and R and T assume one of the forms:",
     "if N >= M,  R = ( R11 ) M  ,   or if N < M,  R = ( R11  R12 ) N,",
     "                (  0  ) N-M                         N   M-N",
     "                   M",
     "where R11 is upper triangular, and",
     "if N <= P,  T = ( 0  T12 ) N,   or if N > P,  T = ( T11 ) N-P,",
     "                 P-N  N                           ( T21 ) P",
     "                                                     P",
     "where T12 or T21 is upper triangular.",
     "In particular, if B is square and nonsingular, the GQR factorization",
     "of A and B implicitly gives the QR factorization of inv(B)*A:",
     "             inv(B)*A = Z**T*(inv(T)*R)",
     "where inv(B) denotes the inverse of the matrix B, and Z**T denotes the",
     "transpose of the matrix Z."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrices A and B. N >= 0."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of columns of the matrix B.  P >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,M)",
       "         On entry, the N-by-M matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(N,M)-by-M upper trapezoidal matrix R (R is",
       "         upper triangular if N >= M); the elements below the diagonal,",
       "         with the array TAUA, represent the orthogonal matrix Q as a",
       "         product of min(N,M) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "TAUA"=>
      ["[out]",
       "         TAUA is DOUBLE PRECISION array, dimension (min(N,M))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Q (see Further Details)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,P)",
       "         On entry, the N-by-P matrix B.",
       "         On exit, if N <= P, the upper triangle of the subarray",
       "         B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T;",
       "         if N > P, the elements on and above the (N-P)-th subdiagonal",
       "         contain the N-by-P upper trapezoidal matrix T; the remaining",
       "         elements, with the array TAUB, represent the orthogonal",
       "         matrix Z as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "TAUB"=>
      ["[out]",
       "         TAUB is DOUBLE PRECISION array, dimension (min(N,P))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Z (see Further Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N,M,P).",
       "         For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),",
       "         where NB1 is the optimal blocksize for the QR factorization",
       "         of an N-by-M matrix, NB2 is the optimal blocksize for the",
       "         RQ factorization of an N-by-P matrix, and NB3 is the optimal",
       "         blocksize for a call of DORMQR.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "sgemlqt"=>
  {"summary"=>
    ["DGEMQRT overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q C            C Q",
     "TRANS = 'T':   Q**T C            C Q**T",
     "where Q is a real orthogonal matrix defined as the product of K",
     "elementary reflectors:",
     "      Q = H(1) H(2) . . . H(K) = I - V T V**T",
     "generated using the compact WY representation as returned by DGELQT.",
     "Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size used for the storage of T.  K >= MB >= 1.",
       "         This must be the same value of MB used to generate T",
       "         in DGELQT."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension (LDV,K)",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGELQT in the first K rows of its array argument A."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by DGELQT, stored as a MB-by-M matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q C, Q**T C, C Q**T or C Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array. The dimension of",
       "         WORK is N*MB if SIDE = 'L', or  M*MB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ztpmlqt"=>
  {"summary"=>
    ["ZTPMQRT applies a complex orthogonal matrix Q obtained from a",
     "\"triangular-pentagonal\" real block reflector H to a general",
     "real matrix C, which consists of two blocks A and B."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**C from the Left;",
       "         = 'R': apply Q or Q**C from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**C."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size used for the storage of T.  K >= MB >= 1.",
       "         This must be the same value of MB used to generate T",
       "         in DTPLQT."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension (LDA,K)",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DTPLQT in B.  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDV >= max(1,M);",
       "         if SIDE = 'R', LDV >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by DTPLQT, stored as a MB-by-K matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension",
       "         (LDA,N) if SIDE = 'L' or",
       "         (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         Q*C or Q**C*C or C*Q or C*Q**C.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         Q*C or Q**C*C or C*Q or C*Q**C.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array. The dimension of WORK is",
       "          N*MB if SIDE = 'L', or  M*MB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chbevd_2stage"=>
  {"summary"=>
    ["CHBEVD_2STAGE computes all the eigenvalues and, optionally, eigenvectors of",
     "a complex Hermitian band matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  If eigenvectors are desired, it",
     "uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array,",
       "                                        dimension (LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK.",
       "         If N <= 1,               LRWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LRWORK must be at least N.",
       "         If JOBZ = 'V' and N > 1, LRWORK must be at least",
       "                       1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of array IWORK.",
       "         If JOBZ = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ = 'V' and N > 1, LIWORK must be at least 3 + 5*N .",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dhgeqz"=>
  {"summary"=>
    ["DHGEQZ computes the eigenvalues of a real matrix pair (H,T),",
     "where H is an upper Hessenberg matrix and T is upper triangular,",
     "using the double-shift QZ method.",
     "Matrix pairs of this type are produced by the reduction to",
     "generalized upper Hessenberg form of a real matrix pair (A,B):",
     "   A = Q1*H*Z1**T,  B = Q1*T*Z1**T,",
     "as computed by DGGHRD.",
     "If JOB='S', then the Hessenberg-triangular pair (H,T) is",
     "also reduced to generalized Schur form,",
     "   H = Q*S*Z**T,  T = Q*P*Z**T,",
     "where Q and Z are orthogonal matrices, P is an upper triangular",
     "matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2",
     "diagonal blocks.",
     "The 1-by-1 blocks correspond to real eigenvalues of the matrix pair",
     "(H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of",
     "eigenvalues.",
     "Additionally, the 2-by-2 upper triangular diagonal blocks of P",
     "corresponding to 2-by-2 blocks of S are reduced to positive diagonal",
     "form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0,",
     "P(j,j) > 0, and P(j+1,j+1) > 0.",
     "Optionally, the orthogonal matrix Q from the generalized Schur",
     "factorization may be postmultiplied into an input matrix Q1, and the",
     "orthogonal matrix Z may be postmultiplied into an input matrix Z1.",
     "If Q1 and Z1 are the orthogonal matrices from DGGHRD that reduced",
     "the matrix pair (A,B) to generalized upper Hessenberg form, then the",
     "output matrices Q1*Q and Z1*Z are the orthogonal factors from the",
     "generalized Schur factorization of (A,B):",
     "   A = (Q1*Q)*S*(Z1*Z)**T,  B = (Q1*Q)*P*(Z1*Z)**T.",
     "To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently,",
     "of (A,B)) are computed as a pair of values (alpha,beta), where alpha is",
     "complex and beta real.",
     "If beta is nonzero, lambda = alpha / beta is an eigenvalue of the",
     "generalized nonsymmetric eigenvalue problem (GNEP)",
     "   A*x = lambda*B*x",
     "and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the",
     "alternate form of the GNEP",
     "   mu*A*y = B*y.",
     "Real eigenvalues can be read directly from the generalized Schur",
     "form:",
     "  alpha = S(i,i), beta = P(i,i).",
     "Ref: C.B. Moler & G.W. Stewart, \"An Algorithm for Generalized Matrix",
     "     Eigenvalue Problems\", SIAM J. Numer. Anal., 10(1973),",
     "     pp. 241--256."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         = 'E': Compute eigenvalues only;",
       "         = 'S': Compute eigenvalues and the Schur form."],
     "COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': Left Schur vectors (Q) are not computed;",
       "         = 'I': Q is initialized to the unit matrix and the matrix Q",
       "                of left Schur vectors of (H,T) is returned;",
       "         = 'V': Q must contain an orthogonal matrix Q1 on entry and",
       "                the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': Right Schur vectors (Z) are not computed;",
       "         = 'I': Z is initialized to the unit matrix and the matrix Z",
       "                of right Schur vectors of (H,T) is returned;",
       "         = 'V': Z must contain an orthogonal matrix Z1 on entry and",
       "                the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices H, T, Q, and Z.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of H which are in",
       "         Hessenberg form.  It is assumed that A is already upper",
       "         triangular in rows and columns 1:ILO-1 and IHI+1:N.",
       "         If N > 0, 1 <= ILO <= IHI <= N; if N = 0, ILO=1 and IHI=0."],
     "H"=>
      ["[in,out]",
       "         H is DOUBLE PRECISION array, dimension (LDH, N)",
       "         On entry, the N-by-N upper Hessenberg matrix H.",
       "         On exit, if JOB = 'S', H contains the upper quasi-triangular",
       "         matrix S from the generalized Schur factorization.",
       "         If JOB = 'E', the diagonal blocks of H match those of S, but",
       "         the rest of H is unspecified."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max( 1, N )."],
     "T"=>
      ["[in,out]",
       "         T is DOUBLE PRECISION array, dimension (LDT, N)",
       "         On entry, the N-by-N upper triangular matrix T.",
       "         On exit, if JOB = 'S', T contains the upper triangular",
       "         matrix P from the generalized Schur factorization;",
       "         2-by-2 diagonal blocks of P corresponding to 2-by-2 blocks of S",
       "         are reduced to positive diagonal form, i.e., if H(j+1,j) is",
       "         non-zero, then T(j+1,j) = T(j,j+1) = 0, T(j,j) > 0, and",
       "         T(j+1,j+1) > 0.",
       "         If JOB = 'E', the diagonal blocks of T match those of P, but",
       "         the rest of T is unspecified."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max( 1, N )."],
     "ALPHAR"=>
      ["[out]",
       "         ALPHAR is DOUBLE PRECISION array, dimension (N)",
       "         The real parts of each scalar alpha defining an eigenvalue",
       "         of GNEP."],
     "ALPHAI"=>
      ["[out]",
       "         ALPHAI is DOUBLE PRECISION array, dimension (N)",
       "         The imaginary parts of each scalar alpha defining an",
       "         eigenvalue of GNEP.",
       "         If ALPHAI(j) is zero, then the j-th eigenvalue is real; if",
       "         positive, then the j-th and (j+1)-st eigenvalues are a",
       "         complex conjugate pair, with ALPHAI(j+1) = -ALPHAI(j)."],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         The scalars beta that define the eigenvalues of GNEP.",
       "         Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and",
       "         beta = BETA(j) represent the j-th eigenvalue of the matrix",
       "         pair (A,B), in one of the forms lambda = alpha/beta or",
       "         mu = beta/alpha.  Since either lambda or mu may overflow,",
       "         they should not, in general, be computed."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the orthogonal matrix Q1 used in",
       "         the reduction of (A,B) to generalized Hessenberg form.",
       "         On exit, if COMPQ = 'I', the orthogonal matrix of left Schur",
       "         vectors of (H,T), and if COMPQ = 'V', the orthogonal matrix",
       "         of left Schur vectors of (A,B).",
       "         Not referenced if COMPQ = 'N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= 1.",
       "         If COMPQ='V' or 'I', then LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the orthogonal matrix Z1 used in",
       "         the reduction of (A,B) to generalized Hessenberg form.",
       "         On exit, if COMPZ = 'I', the orthogonal matrix of",
       "         right Schur vectors of (H,T), and if COMPZ = 'V', the",
       "         orthogonal matrix of right Schur vectors of (A,B).",
       "         Not referenced if COMPZ = 'N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1.",
       "         If COMPZ='V' or 'I', then LDZ >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO >= 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         = 1,...,N: the QZ iteration did not converge.  (H,T) is not",
       "                    in Schur form, but ALPHAR(i), ALPHAI(i), and",
       "                    BETA(i), i=INFO+1,...,N should be correct.",
       "         = N+1,...,2*N: the shift calculation failed.  (H,T) is not",
       "                    in Schur form, but ALPHAR(i), ALPHAI(i), and",
       "                    BETA(i), i=INFO-N+1,...,N should be correct."]}},
 "sgeev"=>
  {"summary"=>
    ["SGEEV computes for an N-by-N real nonsymmetric matrix A, the",
     "eigenvalues and, optionally, the left and/or right eigenvectors.",
     "The right eigenvector v(j) of A satisfies",
     "                 A * v(j) = lambda(j) * v(j)",
     "where lambda(j) is its eigenvalue.",
     "The left eigenvector u(j) of A satisfies",
     "              u(j)**H * A = lambda(j) * u(j)**H",
     "where u(j)**H denotes the conjugate-transpose of u(j).",
     "The computed eigenvectors are normalized to have Euclidean norm",
     "equal to 1 and largest component real."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N': left eigenvectors of A are not computed;",
       "         = 'V': left eigenvectors of A are computed."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N': right eigenvectors of A are not computed;",
       "         = 'V': right eigenvectors of A are computed."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "WR"=>["[out]", "         WR is REAL array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is REAL array, dimension (N)",
       "         WR and WI contain the real and imaginary parts,",
       "         respectively, of the computed eigenvalues.  Complex",
       "         conjugate pairs of eigenvalues appear consecutively",
       "         with the eigenvalue having the positive imaginary part",
       "         first."],
     "VL"=>
      ["[out]",
       "         VL is REAL array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order",
       "         as their eigenvalues.",
       "         If JOBVL = 'N', VL is not referenced.",
       "         If the j-th eigenvalue is real, then u(j) = VL(:,j),",
       "         the j-th column of VL.",
       "         If the j-th and (j+1)-st eigenvalues form a complex",
       "         conjugate pair, then u(j) = VL(:,j) + i*VL(:,j+1) and",
       "         u(j+1) = VL(:,j) - i*VL(:,j+1)."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1; if",
       "         JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is REAL array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order",
       "         as their eigenvalues.",
       "         If JOBVR = 'N', VR is not referenced.",
       "         If the j-th eigenvalue is real, then v(j) = VR(:,j),",
       "         the j-th column of VR.",
       "         If the j-th and (j+1)-st eigenvalues form a complex",
       "         conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and",
       "         v(j+1) = VR(:,j) - i*VR(:,j+1)."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1; if",
       "         JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,3*N), and",
       "         if JOBVL = 'V' or JOBVR = 'V', LWORK >= 4*N.  For good",
       "         performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the QR algorithm failed to compute all the",
       "               eigenvalues, and no eigenvectors have been computed;",
       "               elements i+1:N of WR and WI contain eigenvalues which",
       "               have converged."]}},
 "zpbtf2"=>
  {"summary"=>
    ["ZPBTF2 computes the Cholesky factorization of a complex Hermitian",
     "positive definite band matrix A.",
     "The factorization has the form",
     "   A = U**H * U ,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix, U**H is the conjugate transpose",
     "of U, and L is lower triangular.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H *U or A = L*L**H of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite, and the factorization could not be",
       "              completed."]}},
 "chetrf_rook"=>
  {"summary"=>
    ["CHETRF_ROOK computes the factorization of a comlex Hermitian matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method.",
     "The form of the factorization is",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is Hermitian and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK)).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "ssbgst"=>
  {"summary"=>
    ["SSBGST reduces a real symmetric-definite banded generalized",
     "eigenproblem  A*x = lambda*B*x  to standard form  C*y = lambda*y,",
     "such that C has the same bandwidth as A.",
     "B must have been previously factorized as S**T*S by SPBSTF, using a",
     "split Cholesky factorization. A is overwritten by C = X**T*A*X, where",
     "X = S**(-1)*Q and Q is an orthogonal matrix chosen to preserve the",
     "bandwidth of A."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  do not form the transformation matrix X;",
       "         = 'V':  form X."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the transformed matrix X**T*A*X, stored in the same",
       "         format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in]",
       "         BB is REAL array, dimension (LDBB,N)",
       "         The banded factor S from the split Cholesky factorization of",
       "         B, as returned by SPBSTF, stored in the first KB+1 rows of",
       "         the array."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "X"=>
      ["[out]",
       "         X is REAL array, dimension (LDX,N)",
       "         If VECT = 'V', the n-by-n matrix X.",
       "         If VECT = 'N', the array X is not referenced."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.",
       "         LDX >= max(1,N) if VECT = 'V'; LDX >= 1 otherwise."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "cgerqf"=>
  {"summary"=>
    ["CGERQF computes an RQ factorization of a complex M-by-N matrix A:",
     "A = R * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if m <= n, the upper triangle of the subarray",
       "         A(1:m,n-m+1:n) contains the M-by-M upper triangular matrix R;",
       "         if m >= n, the elements on and above the (m-n)-th subdiagonal",
       "         contain the M-by-N upper trapezoidal matrix R;",
       "         the remaining elements, with the array TAU, represent the",
       "         unitary matrix Q as a product of min(m,n) elementary",
       "         reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhbgvx"=>
  {"summary"=>
    ["ZHBGVX computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite banded eigenproblem, of",
     "the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian",
     "and banded, and B is also positive definite.  Eigenvalues and",
     "eigenvectors can be selected by specifying either all eigenvalues,",
     "a range of values or a range of indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is COMPLEX*16 array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(kb+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**H*S, as returned by ZPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX*16 array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the n-by-n matrix used in the reduction of",
       "         A*x = (lambda)*B*x to standard form, i.e. C*x = (lambda)*x,",
       "         and consequently C to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'N',",
       "         LDQ >= 1. If JOBZ = 'V', LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AP to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i). The eigenvectors are",
       "         normalized so that Z**H*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= N."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is:",
       "            <= N:  then i eigenvectors failed to converge.  Their",
       "                   indices are stored in array IFAIL.",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then ZPBSTF",
       "                   returned INFO = i: B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "zhegs2"=>
  {"summary"=>
    ["ZHEGS2 reduces a complex Hermitian-definite generalized",
     "eigenproblem to standard form.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H *A*L.",
     "B must have been previously factorized as U**H *U or L*L**H by ZPOTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H);",
       "         = 2 or 3: compute U*A*U**H or L**H *A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored, and how B has been factorized.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         as returned by ZPOTRF."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zgetf2"=>
  {"summary"=>
    ["ZGETF2 computes an LU factorization of a general m-by-n matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the right-looking Level 2 BLAS version of the algorithm."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the m by n matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, U(k,k) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "zgbequb"=>
  {"summary"=>
    ["ZGBEQUB computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most",
     "the radix.",
     "R(i) and C(j) are restricted to be a power of the radix between",
     "SMLNUM = smallest safe number and BIGNUM = largest safe number.  Use",
     "of these scaling factors is not guaranteed to reduce the condition",
     "number of A but works well in practice.",
     "This routine differs from ZGEEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled entries' magnitudes are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A.  LDAB >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is DOUBLE PRECISION",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is DOUBLE PRECISION",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "zhetrs_3"=>
  {"summary"=>
    ["ZHETRS_3 solves a system of linear equations A * X = B with a complex",
     "Hermitian matrix A using the factorization computed",
     "by ZHETRF_RK or ZHETRF_BK:",
     "   A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This algorithm is using Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**H)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**H)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by ZHETRF_RK and ZHETRF_BK:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHETRF_RK or ZHETRF_BK."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slagv2"=>
  {"summary"=>
    ["SLAGV2 computes the Generalized Schur factorization of a real 2-by-2",
     "matrix pencil (A,B) where B is upper triangular. This routine",
     "computes orthogonal (rotation) matrices given by CSL, SNL and CSR,",
     "SNR such that",
     "1) if the pencil (A,B) has two real eigenvalues (include 0/0 or 1/0",
     "   types), then",
     "   [ a11 a12 ] := [  CSL  SNL ] [ a11 a12 ] [  CSR -SNR ]",
     "   [  0  a22 ]    [ -SNL  CSL ] [ a21 a22 ] [  SNR  CSR ]",
     "   [ b11 b12 ] := [  CSL  SNL ] [ b11 b12 ] [  CSR -SNR ]",
     "   [  0  b22 ]    [ -SNL  CSL ] [  0  b22 ] [  SNR  CSR ],",
     "2) if the pencil (A,B) has a pair of complex conjugate eigenvalues,",
     "   then",
     "   [ a11 a12 ] := [  CSL  SNL ] [ a11 a12 ] [  CSR -SNR ]",
     "   [ a21 a22 ]    [ -SNL  CSL ] [ a21 a22 ] [  SNR  CSR ]",
     "   [ b11  0  ] := [  CSL  SNL ] [ b11 b12 ] [  CSR -SNR ]",
     "   [  0  b22 ]    [ -SNL  CSL ] [  0  b22 ] [  SNR  CSR ]",
     "   where b11 >= b22 > 0."],
   "param"=>
    {"A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, 2)",
       "         On entry, the 2 x 2 matrix A.",
       "         On exit, A is overwritten by the ``A-part'' of the",
       "         generalized Schur form."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         THe leading dimension of the array A.  LDA >= 2."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, 2)",
       "         On entry, the upper triangular 2 x 2 matrix B.",
       "         On exit, B is overwritten by the ``B-part'' of the",
       "         generalized Schur form."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         THe leading dimension of the array B.  LDB >= 2."],
     "ALPHAR"=>["[out]", "         ALPHAR is REAL array, dimension (2)"],
     "ALPHAI"=>["[out]", "         ALPHAI is REAL array, dimension (2)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (2)",
       "         (ALPHAR(k)+i*ALPHAI(k))/BETA(k) are the eigenvalues of the",
       "         pencil (A,B), k=1,2, i = sqrt(-1).  Note that BETA(k) may",
       "         be zero."],
     "CSL"=>
      ["[out]",
       "         CSL is REAL",
       "         The cosine of the left rotation matrix."],
     "SNL"=>
      ["[out]",
       "         SNL is REAL",
       "         The sine of the left rotation matrix."],
     "CSR"=>
      ["[out]",
       "         CSR is REAL",
       "         The cosine of the right rotation matrix."],
     "SNR"=>
      ["[out]",
       "         SNR is REAL",
       "         The sine of the right rotation matrix."]}},
 "zla_syamv"=>
  {"summary"=>
    ["ZLA_SYAMV  performs the matrix-vector operation",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "n by n symmetric matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is INTEGER",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array A is to be referenced as",
       "          follows:",
       "             UPLO = BLAS_UPPER   Only the upper triangular part of A",
       "                                 is to be referenced.",
       "             UPLO = BLAS_LOWER   Only the lower triangular part of A",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION .",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, DIMENSION ( LDA, n ).",
       "          Before entry, the leading m by n part of the array A must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, n ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, DIMENSION at least",
       "          ( 1 + ( n - 1 )*abs( INCX ) )",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION .",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCY ) )",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit."]}},
 "dopmtr"=>
  {"summary"=>
    ["DOPMTR overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "nq-1 elementary reflectors, as returned by DSPTRD using packed",
     "storage:",
     "if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangular packed storage used in previous",
       "                call to DSPTRD;",
       "         = 'L': Lower triangular packed storage used in previous",
       "                call to DSPTRD."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension",
       "                              (M*(M+1)/2) if SIDE = 'L'",
       "                              (N*(N+1)/2) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by DSPTRD.  AP is modified by the routine but",
       "         restored on exit."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (M-1) if SIDE = 'L'",
       "                                    or (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DSPTRD."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension",
       "                                  (N) if SIDE = 'L'",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dsygvx"=>
  {"summary"=>
    ["DSYGVX computes selected eigenvalues, and optionally, eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A",
     "and B are assumed to be symmetric and B is also positive definite.",
     "Eigenvalues and eigenvectors can be selected by specifying either a",
     "range of values or a range of indices for the desired eigenvalues."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A and B are stored;",
       "         = 'L':  Lower triangle of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix pencil (A,B).  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the symmetric matrix B.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of B contains the",
       "         upper triangular part of the matrix B.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of B contains",
       "         the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing C to tridiagonal form, where C is the symmetric",
       "         matrix of the standard symmetric problem to which the",
       "         generalized problem is transformed.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,8*N).",
       "         For optimal efficiency, LWORK >= (NB+3)*N,",
       "         where NB is the blocksize for DSYTRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  DPOTRF or DSYEVX returned an error code:",
       "            <= N:  if INFO = i, DSYEVX failed to converge;",
       "                   i eigenvectors failed to converge.  Their indices",
       "                   are stored in array IFAIL.",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "cpotf2"=>
  {"summary"=>
    ["CPOTF2 computes the Cholesky factorization of a complex Hermitian",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**H * U ,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**H *U  or A = L*L**H."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite, and the factorization could not be",
       "              completed."]}},
 "claesy"=>
  {"summary"=>
    ["CLAESY computes the eigendecomposition of a 2-by-2 symmetric matrix",
     "   ( ( A, B );( B, C ) )",
     "provided the norm of the matrix of eigenvectors is larger than",
     "some threshold value.",
     "RT1 is the eigenvalue of larger absolute value, and RT2 of",
     "smaller absolute value.  If the eigenvectors are computed, then",
     "on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence",
     "[  CS1     SN1   ] . [ A  B ] . [ CS1    -SN1   ] = [ RT1  0  ]",
     "[ -SN1     CS1   ]   [ B  C ]   [ SN1     CS1   ]   [  0  RT2 ]"],
   "param"=>
    {"A"=>
      ["[in]",
       "         A is COMPLEX",
       "         The ( 1, 1 ) element of input matrix."],
     "B"=>
      ["[in]",
       "         B is COMPLEX",
       "         The ( 1, 2 ) element of input matrix.  The ( 2, 1 ) element",
       "         is also given by B, since the 2-by-2 matrix is symmetric."],
     "C"=>
      ["[in]",
       "         C is COMPLEX",
       "         The ( 2, 2 ) element of input matrix."],
     "RT1"=>
      ["[out]",
       "         RT1 is COMPLEX",
       "         The eigenvalue of larger modulus."],
     "RT2"=>
      ["[out]",
       "         RT2 is COMPLEX",
       "         The eigenvalue of smaller modulus."],
     "EVSCAL"=>
      ["[out]",
       "         EVSCAL is COMPLEX",
       "         The complex value by which the eigenvector matrix was scaled",
       "         to make it orthonormal.  If EVSCAL is zero, the eigenvectors",
       "         were not computed.  This means one of two things:  the 2-by-2",
       "         matrix could not be diagonalized, or the norm of the matrix",
       "         of eigenvectors before scaling was larger than the threshold",
       "         value THRESH (set below)."],
     "CS1"=>["[out]", "         CS1 is COMPLEX"],
     "SN1"=>
      ["[out]",
       "         SN1 is COMPLEX",
       "         If EVSCAL .NE. 0,  ( CS1, SN1 ) is the unit right eigenvector",
       "         for RT1."]}},
 "slaed2"=>
  {"summary"=>
    ["SLAED2 merges the two sets of eigenvalues together into a single",
     "sorted set.  Then it tries to deflate the size of the problem.",
     "There are two ways in which deflation can occur:  when two or more",
     "eigenvalues are close together or if there is a tiny entry in the",
     "Z vector.  For each such occurrence the order of the related secular",
     "equation problem is reduced by one."],
   "param"=>
    {"K"=>
      ["[out]",
       "         K is INTEGER",
       "        The number of non-deflated eigenvalues, and the order of the",
       "        related secular equation. 0 <= K <=N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "        The location of the last eigenvalue in the leading sub-matrix.",
       "        min(1,N) <= N1 <= N/2."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry, D contains the eigenvalues of the two submatrices to",
       "        be combined.",
       "        On exit, D contains the trailing (N-K) updated eigenvalues",
       "        (those which were deflated) sorted into increasing order."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ, N)",
       "        On entry, Q contains the eigenvectors of two submatrices in",
       "        the two square blocks with corners at (1,1), (N1,N1)",
       "        and (N1+1, N1+1), (N,N).",
       "        On exit, Q contains the trailing (N-K) updated eigenvectors",
       "        (those which were deflated) in its last N-K columns."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "INDXQ"=>
      ["[in,out]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        The permutation which separately sorts the two sub-problems",
       "        in D into ascending order.  Note that elements in the second",
       "        half of this permutation must first have N1 added to their",
       "        values. Destroyed on exit."],
     "RHO"=>
      ["[in,out]",
       "         RHO is REAL",
       "        On entry, the off-diagonal element associated with the rank-1",
       "        cut which originally split the two submatrices which are now",
       "        being recombined.",
       "        On exit, RHO has been modified to the value required by",
       "        SLAED3."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension (N)",
       "        On entry, Z contains the updating vector (the last",
       "        row of the first sub-eigenvector matrix and the first row of",
       "        the second sub-eigenvector matrix).",
       "        On exit, the contents of Z have been destroyed by the updating",
       "        process."],
     "DLAMDA"=>
      ["[out]",
       "         DLAMDA is REAL array, dimension (N)",
       "        A copy of the first K eigenvalues which will be used by",
       "        SLAED3 to form the secular equation."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "        The first k values of the final deflation-altered z-vector",
       "        which will be passed to SLAED3."],
     "Q2"=>
      ["[out]",
       "         Q2 is REAL array, dimension (N1**2+(N-N1)**2)",
       "        A copy of the first K eigenvectors which will be used by",
       "        SLAED3 in a matrix multiply (SGEMM) to solve for the new",
       "        eigenvectors."],
     "INDX"=>
      ["[out]",
       "         INDX is INTEGER array, dimension (N)",
       "        The permutation used to sort the contents of DLAMDA into",
       "        ascending order."],
     "INDXC"=>
      ["[out]",
       "         INDXC is INTEGER array, dimension (N)",
       "        The permutation used to arrange the columns of the deflated",
       "        Q matrix into three groups:  the first group contains non-zero",
       "        elements only at and above N1, the second contains",
       "        non-zero elements only below N1, and the third is dense."],
     "INDXP"=>
      ["[out]",
       "         INDXP is INTEGER array, dimension (N)",
       "        The permutation used to place deflated values of D at the end",
       "        of the array.  INDXP(1:K) points to the nondeflated D-values",
       "        and INDXP(K+1:N) points to the deflated eigenvalues."],
     "COLTYP"=>
      ["[out]",
       "         COLTYP is INTEGER array, dimension (N)",
       "        During execution, a label which will indicate which of the",
       "        following types a column in the Q2 matrix is:",
       "        1 : non-zero in the upper half only;",
       "        2 : dense;",
       "        3 : non-zero in the lower half only;",
       "        4 : deflated.",
       "        On exit, COLTYP(i) is the number of columns of type i,",
       "        for i=1 to 4 only."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dlat2s"=>
  {"summary"=>
    ["DLAT2S converts a DOUBLE PRECISION triangular matrix, SA, to a SINGLE",
     "PRECISION triangular matrix, A.",
     "RMAX is the overflow for the SINGLE PRECISION arithmetic",
     "DLAS2S checks that all the entries of A are between -RMAX and",
     "RMAX. If not the conversion is aborted and a flag is raised.",
     "This is an auxiliary routine so there is no argument checking."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows and columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the N-by-N triangular coefficient matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "SA"=>
      ["[out]",
       "         SA is REAL array, dimension (LDSA,N)",
       "         Only the UPLO part of SA is referenced.  On exit, if INFO=0,",
       "         the N-by-N coefficient matrix SA; if INFO>0, the content of",
       "         the UPLO part of SA is unspecified."],
     "LDSA"=>
      ["[in]",
       "         LDSA is INTEGER",
       "         The leading dimension of the array SA.  LDSA >= max(1,M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         = 1:  an entry of the matrix A is greater than the SINGLE",
       "               PRECISION overflow threshold, in this case, the content",
       "               of the UPLO part of SA in exit is unspecified."]}},
 "cpbsvx"=>
  {"summary"=>
    ["CPBSVX uses the Cholesky factorization A = U**H*U or A = L*L**H to",
     "compute the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite band matrix and X",
     "and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "ztgsna"=>
  {"summary"=>
    ["ZTGSNA estimates reciprocal condition numbers for specified",
     "eigenvalues and/or eigenvectors of a matrix pair (A, B).",
     "(A, B) must be in generalized Schur canonical form, that is, A and",
     "B are both upper triangular."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for",
       "         eigenvalues (S) or eigenvectors (DIF):",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for eigenvectors only (DIF);",
       "         = 'B': for both eigenvalues and eigenvectors (S and DIF)."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute condition numbers for all eigenpairs;",
       "         = 'S': compute condition numbers for selected eigenpairs",
       "                specified by the array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenpairs for which",
       "         condition numbers are required. To select condition numbers",
       "         for the corresponding j-th eigenvalue and/or eigenvector,",
       "         SELECT(j) must be set to .TRUE..",
       "         If HOWMNY = 'A', SELECT is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the square matrix pair (A, B). N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The upper triangular matrix A in the pair (A,B)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         The upper triangular matrix B in the pair (A, B)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is COMPLEX*16 array, dimension (LDVL,M)",
       "         IF JOB = 'E' or 'B', VL must contain left eigenvectors of",
       "         (A, B), corresponding to the eigenpairs specified by HOWMNY",
       "         and SELECT.  The eigenvectors must be stored in consecutive",
       "         columns of VL, as returned by ZTGEVC.",
       "         If JOB = 'V', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL. LDVL >= 1; and",
       "         If JOB = 'E' or 'B', LDVL >= N."],
     "VR"=>
      ["[in]",
       "         VR is COMPLEX*16 array, dimension (LDVR,M)",
       "         IF JOB = 'E' or 'B', VR must contain right eigenvectors of",
       "         (A, B), corresponding to the eigenpairs specified by HOWMNY",
       "         and SELECT.  The eigenvectors must be stored in consecutive",
       "         columns of VR, as returned by ZTGEVC.",
       "         If JOB = 'V', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR. LDVR >= 1;",
       "         If JOB = 'E' or 'B', LDVR >= N."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (MM)",
       "         If JOB = 'E' or 'B', the reciprocal condition numbers of the",
       "         selected eigenvalues, stored in consecutive elements of the",
       "         array.",
       "         If JOB = 'V', S is not referenced."],
     "DIF"=>
      ["[out]",
       "         DIF is DOUBLE PRECISION array, dimension (MM)",
       "         If JOB = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the selected eigenvectors, stored in consecutive",
       "         elements of the array.",
       "         If the eigenvalues cannot be reordered to compute DIF(j),",
       "         DIF(j) is set to 0; this can only occur when the true value",
       "         would be very small anyway.",
       "         For each eigenvalue/vector specified by SELECT, DIF stores",
       "         a Frobenius norm-based estimate of Difl.",
       "         If JOB = 'E', DIF is not referenced."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of elements in the arrays S and DIF. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of elements of the arrays S and DIF used to store",
       "         the specified condition numbers; for each selected eigenvalue",
       "         one element is used. If HOWMNY = 'A', M is set to N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         If JOB = 'V' or 'B', LWORK >= max(1,2*N*N)."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N+2)",
       "         If JOB = 'E', IWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: Successful exit",
       "         < 0: If INFO = -i, the i-th argument had an illegal value"]}},
 "dgerqf"=>
  {"summary"=>
    ["DGERQF computes an RQ factorization of a real M-by-N matrix A:",
     "A = R * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if m <= n, the upper triangle of the subarray",
       "         A(1:m,n-m+1:n) contains the M-by-M upper triangular matrix R;",
       "         if m >= n, the elements on and above the (m-n)-th subdiagonal",
       "         contain the M-by-N upper trapezoidal matrix R;",
       "         the remaining elements, with the array TAU, represent the",
       "         orthogonal matrix Q as a product of min(m,n) elementary",
       "         reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlanhs"=>
  {"summary"=>
    ["DLANHS  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "Hessenberg matrix A.",
     "   DLANHS = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANHS as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, DLANHS is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The n by n upper Hessenberg matrix A; the part of A below the",
       "         first sub-diagonal is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "zgecon"=>
  {"summary"=>
    ["ZGECON estimates the reciprocal of the condition number of a general",
     "complex matrix A, in either the 1-norm or the infinity-norm, using",
     "the LU factorization computed by ZGETRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by ZGETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "csytri_3x"=>
  {"summary"=>
    ["CSYTRI_3X computes the inverse of a complex symmetric indefinite",
     "matrix A using the factorization computed by CSYTRF_RK or CSYTRF_BK:",
     "    A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by CSYTRF_RK and CSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the symmetric inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF_RK or CSYTRF_BK."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX array, dimension (N+NB+1,NB+3)."],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "dpbstf"=>
  {"summary"=>
    ["DPBSTF computes a split Cholesky factorization of a real",
     "symmetric positive definite band matrix A.",
     "This routine is designed to be used in conjunction with DSBGST.",
     "The factorization has the form  A = S**T*S  where S is a band matrix",
     "of the same bandwidth as A and the following structure:",
     "  S = ( U    )",
     "      ( M  L )",
     "where U is upper triangular of order m = (n+kd)/2, and L is lower",
     "triangular of order n-m."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first kd+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the factor S from the split Cholesky",
       "         factorization A = S**T*S. See Further Details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, the factorization could not be completed,",
       "              because the updated element a(i,i) was negative; the",
       "              matrix A is not positive definite."]}},
 "slascl2"=>
  {"summary"=>
    ["SLASCL2 performs a diagonal scaling on a vector:",
     "  x <-- D * x",
     "where the diagonal matrix D is stored as a vector.",
     "Eventually to be replaced by BLAS_sge_diag_scale in the new BLAS",
     "standard."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "    The number of rows of D and X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of columns of X. N >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, length M",
       "    Diagonal matrix D, stored as a vector of length M."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,N)",
       "    On entry, the vector X to be scaled by D.",
       "    On exit, the scaled vector."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the vector X. LDX >= M."]}},
 "sgeqrt3"=>
  {"summary"=>
    ["SGEQRT3 recursively computes a QR factorization of a real M-by-N",
     "matrix A, using the compact WY representation of Q.",
     "Based on the algorithm of Elmroth and Gustavson,",
     "IBM J. Res. Develop. Vol 44 No. 4 July 2000."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the real M-by-N matrix A.  On exit, the elements on and",
       "         above the diagonal contain the N-by-N upper triangular matrix R; the",
       "         elements below the diagonal are the columns of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "sorbdb2"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= min(M-P,Q,M-Q)."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is REAL array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is REAL array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is REAL array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is REAL array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is REAL array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is REAL array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zpptri"=>
  {"summary"=>
    ["ZPPTRI computes the inverse of a complex Hermitian positive definite",
     "matrix A using the Cholesky factorization A = U**H*U or A = L*L**H",
     "computed by ZPPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor is stored in AP;",
       "         = 'L':  Lower triangular factor is stored in AP."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the triangular factor U or L from the Cholesky",
       "         factorization A = U**H*U or A = L*L**H, packed columnwise as",
       "         a linear array.  The j-th column of U or L is stored in the",
       "         array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n.",
       "         On exit, the upper or lower triangle of the (Hermitian)",
       "         inverse of A, overwriting the input factor U or L."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "dsyev"=>
  {"summary"=>
    ["DSYEV computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric matrix A."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,3*N-1).",
       "         For optimal efficiency, LWORK >= (NB+2)*N,",
       "         where NB is the blocksize for DSYTRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "sgbtf2"=>
  {"summary"=>
    ["SGBTF2 computes an LU factorization of a real m-by-n band matrix A",
     "using partial pivoting with row interchanges.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(kl+ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = +i, U(i,i) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "zla_wwaddw"=>
  {"summary"=>
    ["   ZLA_WWADDW adds a vector W into a doubled-single vector (X, Y).",
     "   This works for all extant IBM's hex and binary floating point",
     "   arithmetics, but not for decimal."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "           The length of vectors X, Y, and W."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (N)",
       "           The first part of the doubled-single accumulation vector."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension (N)",
       "           The second part of the doubled-single accumulation vector."],
     "W"=>
      ["[in]",
       "         W is COMPLEX*16 array, dimension (N)",
       "           The vector to be added."]}},
 "zlanhf"=>
  {"summary"=>
    ["ZLANHF  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex Hermitian matrix A in RFP format.",
     "   ZLANHF = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a  matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER",
       "           Specifies the value to be returned in ZLANHF as described",
       "           above."],
     "TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER",
       "           Specifies whether the RFP format of A is normal or",
       "           conjugate-transposed format.",
       "           = 'N':  RFP format is Normal",
       "           = 'C':  RFP format is Conjugate-transposed"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER",
       "           On entry, UPLO specifies whether the RFP matrix A came from",
       "           an upper or lower triangular matrix as follows:",
       "           UPLO = 'U' or 'u' RFP A came from an upper triangular",
       "           matrix",
       "           UPLO = 'L' or 'l' RFP A came from a  lower triangular",
       "           matrix"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "           The order of the matrix A.  N >= 0.  When N = 0, ZLANHF is",
       "           set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension ( N*(N+1)/2 );",
       "           On entry, the matrix A in RFP Format.",
       "           RFP Format is described by TRANSR, UPLO and N as follows:",
       "           If TRANSR='N' then RFP A is (0:N,0:K-1) when N is even;",
       "           K=N/2. RFP A is (0:N-1,0:K) when N is odd; K=N/2. If",
       "           TRANSR = 'C' then RFP is the Conjugate-transpose of RFP A",
       "           as defined when TRANSR = 'N'. The contents of RFP A are",
       "           defined by UPLO as follows: If UPLO = 'U' the RFP A",
       "           contains the ( N*(N+1)/2 ) elements of upper packed A",
       "           either in normal or conjugate-transpose Format. If",
       "           UPLO = 'L' the RFP A contains the ( N*(N+1) /2 ) elements",
       "           of lower packed A either in normal or conjugate-transpose",
       "           Format. The LDA of RFP A is (N+1)/2 when TRANSR = 'C'. When",
       "           TRANSR is 'N' the LDA is N+1 when N is even and is N when",
       "           is odd. See the Note below for more details.",
       "           Unchanged on exit."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LWORK),",
       "           where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "           WORK is not referenced."]}},
 "zsycon_rook"=>
  {"summary"=>
    ["ZSYCON_ROOK estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex symmetric matrix A using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by ZSYTRF_ROOK.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF_ROOK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slasd8"=>
  {"summary"=>
    ["SLASD8 finds the square roots of the roots of the secular equation,",
     "as defined by the values in DSIGMA and Z. It makes the appropriate",
     "calls to SLASD4, and stores, for each  element in D, the distance",
     "to its two nearest poles (elements in DSIGMA). It also updates",
     "the arrays VF and VL, the first and last components of all the",
     "right singular vectors of the original bidiagonal matrix.",
     "SLASD8 is called from SLASD6."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "         Specifies whether singular vectors are to be computed in",
       "         factored form in the calling routine:",
       "         = 0: Compute singular values only.",
       "         = 1: Compute singular vectors in factored form as well."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of terms in the rational function to be solved",
       "         by SLASD4.  K >= 1."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension ( K )",
       "         On output, D contains the updated singular values."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension ( K )",
       "         On entry, the first K elements of this array contain the",
       "         components of the deflation-adjusted updating row vector.",
       "         On exit, Z is updated."],
     "VF"=>
      ["[in,out]",
       "         VF is REAL array, dimension ( K )",
       "         On entry, VF contains  information passed through DBEDE8.",
       "         On exit, VF contains the first K components of the first",
       "         components of all right singular vectors of the bidiagonal",
       "         matrix."],
     "VL"=>
      ["[in,out]",
       "         VL is REAL array, dimension ( K )",
       "         On entry, VL contains  information passed through DBEDE8.",
       "         On exit, VL contains the first K components of the last",
       "         components of all right singular vectors of the bidiagonal",
       "         matrix."],
     "DIFL"=>
      ["[out]",
       "         DIFL is REAL array, dimension ( K )",
       "         On exit, DIFL(I) = D(I) - DSIGMA(I)."],
     "DIFR"=>
      ["[out]",
       "         DIFR is REAL array,",
       "                  dimension ( LDDIFR, 2 ) if ICOMPQ = 1 and",
       "                  dimension ( K ) if ICOMPQ = 0.",
       "         On exit, DIFR(I,1) = D(I) - DSIGMA(I+1), DIFR(K,1) is not",
       "         defined and will not be referenced.",
       "         If ICOMPQ = 1, DIFR(1:K,2) is an array containing the",
       "         normalizing factors for the right singular vector matrix."],
     "LDDIFR"=>
      ["[in]",
       "         LDDIFR is INTEGER",
       "         The leading dimension of DIFR, must be at least K."],
     "DSIGMA"=>
      ["[in,out]",
       "         DSIGMA is REAL array, dimension ( K )",
       "         On entry, the first K elements of this array contain the old",
       "         roots of the deflated updating problem.  These are the poles",
       "         of the secular equation.",
       "         On exit, the elements of DSIGMA may be very slightly altered",
       "         in value."],
     "WORK"=>
      ["[out]", "         WORK is REAL array, dimension at least 3 * K"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, a singular value did not converge"]}},
 "slartg"=>
  {"summary"=>
    ["SLARTG generate a plane rotation so that",
     "   [  CS  SN  ]  .  [ F ]  =  [ R ]   where CS**2 + SN**2 = 1.",
     "   [ -SN  CS  ]     [ G ]     [ 0 ]",
     "This is a slower, more accurate version of the BLAS1 routine SROTG,",
     "with the following other differences:",
     "   F and G are unchanged on return.",
     "   If G=0, then CS=1 and SN=0.",
     "   If F=0 and (G .ne. 0), then CS=0 and SN=1 without doing any",
     "      floating point operations (saves work in SBDSQR when",
     "      there are zeros on the diagonal).",
     "If F exceeds G in magnitude, CS will be positive."],
   "param"=>
    {"F"=>
      ["[in]",
       "         F is REAL",
       "         The first component of vector to be rotated."],
     "G"=>
      ["[in]",
       "         G is REAL",
       "         The second component of vector to be rotated."],
     "CS"=>
      ["[out]", "         CS is REAL", "         The cosine of the rotation."],
     "SN"=>
      ["[out]", "         SN is REAL", "         The sine of the rotation."],
     "R"=>
      ["[out]",
       "         R is REAL",
       "         The nonzero component of the rotated vector.",
       " This version has a few statements commented out for thread safety",
       " (machine parameters are computed on each entry). 10 feb 03, SJH."]}},
 "spptrf"=>
  {"summary"=>
    ["SPPTRF computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A stored in packed format.",
     "The factorization has the form",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**T*U or A = L*L**T, in the same",
       "         storage format as A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "sstemr"=>
  {"summary"=>
    ["SSTEMR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix T. Any such unreduced matrix has",
     "a well defined set of pairwise different real eigenvalues, the corresponding",
     "real eigenvectors are pairwise orthogonal.",
     "The spectrum may be computed either completely or partially by specifying",
     "either an interval (VL,VU] or a range of indices IL:IU for the desired",
     "eigenvalues.",
     "Depending on the number of desired eigenvalues, these are computed either",
     "by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are",
     "computed by the use of various suitable L D L^T factorizations near clusters",
     "of close eigenvalues (referred to as RRRs, Relatively Robust",
     "Representations). An informal sketch of the algorithm follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "For more details, see:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Further Details",
     "1.SSTEMR works only on machines which follow IEEE-754",
     "floating-point standard in their handling of infinities and NaNs.",
     "This permits the use of efficient inner loops avoiding a check for",
     "zero divisors."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal matrix",
       "         T. On exit, D is overwritten."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the tridiagonal",
       "         matrix T in elements 1 to N-1 of E. E(N) need not be set on",
       "         input, but is used internally as workspace.",
       "         On exit, E is overwritten."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', and if INFO = 0, then the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix T",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and can be computed with a workspace",
       "         query by setting NZC = -1, see below."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', then LDZ >= max(1,N)."],
     "NZC"=>
      ["[in]",
       "         NZC is INTEGER",
       "         The number of eigenvectors to be held in the array Z.",
       "         If RANGE = 'A', then NZC >= max(1,N).",
       "         If RANGE = 'V', then NZC >= the number of eigenvalues in (VL,VU].",
       "         If RANGE = 'I', then NZC >= IU-IL+1.",
       "         If NZC = -1, then a workspace query is assumed; the",
       "         routine calculates the number of columns of the array Z that",
       "         are needed to hold the eigenvectors.",
       "         This value is returned as the first entry of the Z array, and",
       "         no error message related to NZC is issued by XERBLA."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER ARRAY, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th computed eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is relevant in the case when the matrix",
       "         is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0."],
     "TRYRAC"=>
      ["[in,out]",
       "         TRYRAC is LOGICAL",
       "         If TRYRAC.EQ..TRUE., indicates that the code should check whether",
       "         the tridiagonal matrix defines its eigenvalues to high relative",
       "         accuracy.  If so, the code uses relative-accuracy preserving",
       "         algorithms that might be (a bit) slower depending on the matrix.",
       "         If the matrix does not define its eigenvalues to high relative",
       "         accuracy, the code can uses possibly faster algorithms.",
       "         If TRYRAC.EQ..FALSE., the code is not required to guarantee",
       "         relatively accurate eigenvalues and can use the fastest possible",
       "         techniques.",
       "         On exit, a .TRUE. TRYRAC will be set to .FALSE. if the matrix",
       "         does not define its eigenvalues to high relative accuracy."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal",
       "         (and minimal) LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,18*N)",
       "         if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (LIWORK)",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N)",
       "         if the eigenvectors are desired, and LIWORK >= max(1,8*N)",
       "         if only the eigenvalues are to be computed.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = 1X, internal error in SLARRE,",
       "               if INFO = 2X, internal error in SLARRV.",
       "               Here, the digit X = ABS( IINFO ) < 10, where IINFO is",
       "               the nonzero error code returned by SLARRE or",
       "               SLARRV, respectively."]}},
 "zgejsv"=>
  {"summary"=>
    ["ZGEJSV computes the singular value decomposition (SVD) of a complex M-by-N",
     "matrix [A], where M >= N. The SVD of [A] is written as",
     "             [A] = [U] * [SIGMA] * [V]^*,",
     "where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N",
     "diagonal elements, [U] is an M-by-N (or M-by-M) unitary matrix, and",
     "[V] is an N-by-N unitary matrix. The diagonal elements of [SIGMA] are",
     "the singular values of [A]. The columns of [U] and [V] are the left and",
     "the right singular vectors of [A], respectively. The matrices [U] and [V]",
     "are computed and stored in the arrays U and V, respectively. The diagonal",
     "of [SIGMA] is computed and stored in the array SVA."],
   "param"=>
    {"JOBA"=>
      ["[in]",
       "         JOBA is CHARACTER*1",
       "        Specifies the level of accuracy:",
       "      = 'C': This option works well (high relative accuracy) if A = B * D,",
       "             with well-conditioned B and arbitrary diagonal matrix D.",
       "             The accuracy cannot be spoiled by COLUMN scaling. The",
       "             accuracy of the computed output depends on the condition of",
       "             B, and the procedure aims at the best theoretical accuracy.",
       "             The relative error max_{i=1:N}|d sigma_i| / sigma_i is",
       "             bounded by f(M,N)*epsilon* cond(B), independent of D.",
       "             The input matrix is preprocessed with the QRF with column",
       "             pivoting. This initial preprocessing and preconditioning by",
       "             a rank revealing QR factorization is common for all values of",
       "             JOBA. Additional actions are specified as follows:",
       "      = 'E': Computation as with 'C' with an additional estimate of the",
       "             condition number of B. It provides a realistic error bound.",
       "      = 'F': If A = D1 * C * D2 with ill-conditioned diagonal scalings",
       "             D1, D2, and well-conditioned matrix C, this option gives",
       "             higher accuracy than the 'C' option. If the structure of the",
       "             input matrix is not known, and relative accuracy is",
       "             desirable, then this option is advisable. The input matrix A",
       "             is preprocessed with QR factorization with FULL (row and",
       "             column) pivoting.",
       "      = 'G'  Computation as with 'F' with an additional estimate of the",
       "             condition number of B, where A=B*D. If A has heavily weighted",
       "             rows, then using this condition number gives too pessimistic",
       "             error bound.",
       "      = 'A': Small singular values are not well determined by the data ",
       "             and are considered as noisy; the matrix is treated as",
       "             numerically rank defficient. The error in the computed",
       "             singular values is bounded by f(m,n)*epsilon*||A||.",
       "             The computed SVD A = U * S * V^* restores A up to",
       "             f(m,n)*epsilon*||A||.",
       "             This gives the procedure the licence to discard (set to zero)",
       "             all singular values below N*epsilon*||A||.",
       "      = 'R': Similar as in 'A'. Rank revealing property of the initial",
       "             QR factorization is used do reveal (using triangular factor)",
       "             a gap sigma_{r+1} < epsilon * sigma_r in which case the",
       "             numerical RANK is declared to be r. The SVD is computed with",
       "             absolute error bounds, but more accurately than with 'A'."],
     "JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "        Specifies whether to compute the columns of U:",
       "      = 'U': N columns of U are returned in the array U.",
       "      = 'F': full set of M left sing. vectors is returned in the array U.",
       "      = 'W': U may be used as workspace of length M*N. See the description",
       "             of U.",
       "      = 'N': U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "        Specifies whether to compute the matrix V:",
       "      = 'V': N columns of V are returned in the array V; Jacobi rotations",
       "             are not explicitly accumulated.",
       "      = 'J': N columns of V are returned in the array V, but they are",
       "             computed as the product of Jacobi rotations, if JOBT .EQ. 'N'.",
       "      = 'W': V may be used as workspace of length N*N. See the description",
       "             of V.",
       "      = 'N': V is not computed."],
     "JOBR"=>
      ["[in]",
       "         JOBR is CHARACTER*1",
       "        Specifies the RANGE for the singular values. Issues the licence to",
       "        set to zero small positive singular values if they are outside",
       "        specified range. If A .NE. 0 is scaled so that the largest singular",
       "        value of c*A is around SQRT(BIG), BIG=DLAMCH('O'), then JOBR issues",
       "        the licence to kill columns of A whose norm in c*A is less than",
       "        SQRT(SFMIN) (for JOBR.EQ.'R'), or less than SMALL=SFMIN/EPSLN,",
       "        where SFMIN=DLAMCH('S'), EPSLN=DLAMCH('E').",
       "      = 'N': Do not kill small columns of c*A. This option assumes that",
       "             BLAS and QR factorizations and triangular solvers are",
       "             implemented to work in that range. If the condition of A",
       "             is greater than BIG, use ZGESVJ.",
       "      = 'R': RESTRICTED range for sigma(c*A) is [SQRT(SFMIN), SQRT(BIG)]",
       "             (roughly, as described above). This option is recommended.",
       "                                            ===========================",
       "        For computing the singular values in the FULL range [SFMIN,BIG]",
       "        use ZGESVJ."],
     "JOBT"=>
      ["[in]",
       "         JOBT is CHARACTER*1",
       "        If the matrix is square then the procedure may determine to use",
       "        transposed A if A^* seems to be better with respect to convergence.",
       "        If the matrix is not square, JOBT is ignored. ",
       "        The decision is based on two values of entropy over the adjoint",
       "        orbit of A^* * A. See the descriptions of WORK(6) and WORK(7).",
       "      = 'T': transpose if entropy test indicates possibly faster",
       "        convergence of Jacobi process if A^* is taken as input. If A is",
       "        replaced with A^*, then the row pivoting is included automatically.",
       "      = 'N': do not speculate.",
       "        The option 'T' can be used to compute only the singular values, or",
       "        the full SVD (U, SIGMA and V). For only one set of singular vectors",
       "        (U or V), the caller should provide both U and V, as one of the",
       "        matrices is used as workspace if the matrix A is transposed.",
       "        The implementer can easily remove this constraint and make the",
       "        code more complicated. See the descriptions of U and V.",
       "        In general, this option is considered experimental, and 'N'; should",
       "        be preferred. This is subject to changes in the future."],
     "JOBP"=>
      ["[in]",
       "         JOBP is CHARACTER*1",
       "        Issues the licence to introduce structured perturbations to drown",
       "        denormalized numbers. This licence should be active if the",
       "        denormals are poorly implemented, causing slow computation,",
       "        especially in cases of fast convergence (!). For details see [1,2].",
       "        For the sake of simplicity, this perturbations are included only",
       "        when the full SVD or only the singular values are requested. The",
       "        implementer/user can easily add the perturbation for the cases of",
       "        computing one set of singular vectors.",
       "      = 'P': introduce perturbation",
       "      = 'N': do not perturb"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "        The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The number of columns of the input matrix A. M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "SVA"=>
      ["[out]",
       "         SVA is DOUBLE PRECISION array, dimension (N)",
       "         On exit,",
       "         - For WORK(1)/WORK(2) = ONE: The singular values of A. During the",
       "           computation SVA contains Euclidean column norms of the",
       "           iterated matrices in the array A.",
       "         - For WORK(1) .NE. WORK(2): The singular values of A are",
       "           (WORK(1)/WORK(2)) * SVA(1:N). This factored form is used if",
       "           sigma_max(A) overflows or if small singular values have been",
       "           saved from underflow by scaling the input matrix A.",
       "         - If JOBR='R' then some of the singular values may be returned",
       "           as exact zeros obtained by \"set to zero\" because they are",
       "           below the numerical rank threshold or are denormalized numbers."],
     "U"=>
      ["[out]",
       "         U is COMPLEX*16 array, dimension ( LDU, N )",
       "         If JOBU = 'U', then U contains on exit the M-by-N matrix of",
       "                        the left singular vectors.",
       "         If JOBU = 'F', then U contains on exit the M-by-M matrix of",
       "                        the left singular vectors, including an ONB",
       "                        of the orthogonal complement of the Range(A).",
       "         If JOBU = 'W'  .AND. (JOBV.EQ.'V' .AND. JOBT.EQ.'T' .AND. M.EQ.N),",
       "                        then U is used as workspace if the procedure",
       "                        replaces A with A^*. In that case, [V] is computed",
       "                        in U as left singular vectors of A^* and then",
       "                        copied back to the V array. This 'W' option is just",
       "                        a reminder to the caller that in this case U is",
       "                        reserved as workspace of length N*N.",
       "         If JOBU = 'N'  U is not referenced, unless JOBT='T'."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U,  LDU >= 1.",
       "         IF  JOBU = 'U' or 'F' or 'W',  then LDU >= M."],
     "V"=>
      ["[out]",
       "         V is COMPLEX*16 array, dimension ( LDV, N )",
       "         If JOBV = 'V', 'J' then V contains on exit the N-by-N matrix of",
       "                        the right singular vectors;",
       "         If JOBV = 'W', AND (JOBU.EQ.'U' AND JOBT.EQ.'T' AND M.EQ.N),",
       "                        then V is used as workspace if the pprocedure",
       "                        replaces A with A^*. In that case, [U] is computed",
       "                        in V as right singular vectors of A^* and then",
       "                        copied back to the U array. This 'W' option is just",
       "                        a reminder to the caller that in this case V is",
       "                        reserved as workspace of length N*N.",
       "         If JOBV = 'N'  V is not referenced, unless JOBT='T'."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V' or 'J' or 'W', then LDV >= N."],
     "CWORK"=>
      ["[out]",
       "         CWORK is COMPLEX*16 array, dimension (MAX(2,LWORK))",
       "         If the call to ZGEJSV is a workspace query (indicated by LWORK=-1 or",
       "         LRWORK=-1), then on exit CWORK(1) contains the required length of",
       "         CWORK for the job parameters used in the call."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         Length of CWORK to confirm proper allocation of workspace.",
       "         LWORK depends on the job:",
       "         1. If only SIGMA is needed ( JOBU.EQ.'N', JOBV.EQ.'N' ) and",
       "           1.1 .. no scaled condition estimate required (JOBA.NE.'E'.AND.JOBA.NE.'G'):",
       "              LWORK >= 2*N+1. This is the minimal requirement.",
       "              ->> For optimal performance (blocked code) the optimal value",
       "              is LWORK >= N + (N+1)*NB. Here NB is the optimal",
       "              block size for ZGEQP3 and ZGEQRF.",
       "              In general, optimal LWORK is computed as",
       "              LWORK >= max(N+LWORK(ZGEQP3),N+LWORK(ZGEQRF), LWORK(ZGESVJ)).",
       "           1.2. .. an estimate of the scaled condition number of A is",
       "              required (JOBA='E', or 'G'). In this case, LWORK the minimal",
       "              requirement is LWORK >= N*N + 2*N.",
       "              ->> For optimal performance (blocked code) the optimal value",
       "              is LWORK >= max(N+(N+1)*NB, N*N+2*N)=N**2+2*N.",
       "              In general, the optimal length LWORK is computed as",
       "              LWORK >= max(N+LWORK(ZGEQP3),N+LWORK(ZGEQRF), LWORK(ZGESVJ),",
       "                           N*N+LWORK(ZPOCON)).",
       "         2. If SIGMA and the right singular vectors are needed (JOBV.EQ.'V'),",
       "            (JOBU.EQ.'N')",
       "           2.1   .. no scaled condition estimate requested (JOBE.EQ.'N'):    ",
       "           -> the minimal requirement is LWORK >= 3*N.",
       "           -> For optimal performance, ",
       "              LWORK >= max(N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,",
       "              where NB is the optimal block size for ZGEQP3, ZGEQRF, ZGELQ,",
       "              ZUNMLQ. In general, the optimal length LWORK is computed as",
       "              LWORK >= max(N+LWORK(ZGEQP3), N+LWORK(ZGESVJ),",
       "                      N+LWORK(ZGELQF), 2*N+LWORK(ZGEQRF), N+LWORK(ZUNMLQ)).",
       "           2.2 .. an estimate of the scaled condition number of A is",
       "              required (JOBA='E', or 'G').",
       "           -> the minimal requirement is LWORK >= 3*N.      ",
       "           -> For optimal performance, ",
       "              LWORK >= max(N+(N+1)*NB, 2*N,2*N+N*NB)=2*N+N*NB,",
       "              where NB is the optimal block size for ZGEQP3, ZGEQRF, ZGELQ,",
       "              ZUNMLQ. In general, the optimal length LWORK is computed as",
       "              LWORK >= max(N+LWORK(ZGEQP3), LWORK(ZPOCON), N+LWORK(ZGESVJ),",
       "                      N+LWORK(ZGELQF), 2*N+LWORK(ZGEQRF), N+LWORK(ZUNMLQ)).   ",
       "         3. If SIGMA and the left singular vectors are needed",
       "           3.1  .. no scaled condition estimate requested (JOBE.EQ.'N'):",
       "           -> the minimal requirement is LWORK >= 3*N.",
       "           -> For optimal performance:",
       "              if JOBU.EQ.'U' :: LWORK >= max(3*N, N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,",
       "              where NB is the optimal block size for ZGEQP3, ZGEQRF, ZUNMQR.",
       "              In general, the optimal length LWORK is computed as",
       "              LWORK >= max(N+LWORK(ZGEQP3), 2*N+LWORK(ZGEQRF), N+LWORK(ZUNMQR)). ",
       "           3.2  .. an estimate of the scaled condition number of A is",
       "              required (JOBA='E', or 'G').",
       "           -> the minimal requirement is LWORK >= 3*N.",
       "           -> For optimal performance:",
       "              if JOBU.EQ.'U' :: LWORK >= max(3*N, N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,",
       "              where NB is the optimal block size for ZGEQP3, ZGEQRF, ZUNMQR.",
       "              In general, the optimal length LWORK is computed as",
       "              LWORK >= max(N+LWORK(ZGEQP3),N+LWORK(ZPOCON),",
       "                       2*N+LWORK(ZGEQRF), N+LWORK(ZUNMQR)).",
       "         4. If the full SVD is needed: (JOBU.EQ.'U' or JOBU.EQ.'F') and ",
       "           4.1. if JOBV.EQ.'V'  ",
       "              the minimal requirement is LWORK >= 5*N+2*N*N. ",
       "           4.2. if JOBV.EQ.'J' the minimal requirement is ",
       "              LWORK >= 4*N+N*N.",
       "           In both cases, the allocated CWORK can accomodate blocked runs",
       "           of ZGEQP3, ZGEQRF, ZGELQF, SUNMQR, ZUNMLQ.",
       "         If the call to ZGEJSV is a workspace query (indicated by LWORK=-1 or",
       "         LRWORK=-1), then on exit CWORK(1) contains the optimal and CWORK(2) contains the",
       "         minimal length of CWORK for the job parameters used in the call."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (MAX(7,LWORK))",
       "         On exit,",
       "         RWORK(1) = Determines the scaling factor SCALE = RWORK(2) / RWORK(1)",
       "                   such that SCALE*SVA(1:N) are the computed singular values",
       "                   of A. (See the description of SVA().)",
       "         RWORK(2) = See the description of RWORK(1).",
       "         RWORK(3) = SCONDA is an estimate for the condition number of",
       "                   column equilibrated A. (If JOBA .EQ. 'E' or 'G')",
       "                   SCONDA is an estimate of SQRT(||(R^* * R)^(-1)||_1).",
       "                   It is computed using SPOCON. It holds",
       "                   N^(-1/4) * SCONDA <= ||R^(-1)||_2 <= N^(1/4) * SCONDA",
       "                   where R is the triangular factor from the QRF of A.",
       "                   However, if R is truncated and the numerical rank is",
       "                   determined to be strictly smaller than N, SCONDA is",
       "                   returned as -1, thus indicating that the smallest",
       "                   singular values might be lost.",
       "         If full SVD is needed, the following two condition numbers are",
       "         useful for the analysis of the algorithm. They are provied for",
       "         a developer/implementer who is familiar with the details of",
       "         the method.",
       "         RWORK(4) = an estimate of the scaled condition number of the",
       "                   triangular factor in the first QR factorization.",
       "         RWORK(5) = an estimate of the scaled condition number of the",
       "                   triangular factor in the second QR factorization.",
       "         The following two parameters are computed if JOBT .EQ. 'T'.",
       "         They are provided for a developer/implementer who is familiar",
       "         with the details of the method.",
       "         RWORK(6) = the entropy of A^* * A :: this is the Shannon entropy",
       "                   of diag(A^* * A) / Trace(A^* * A) taken as point in the",
       "                   probability simplex.",
       "         RWORK(7) = the entropy of A * A^*. (See the description of RWORK(6).)",
       "         If the call to ZGEJSV is a workspace query (indicated by LWORK=-1 or",
       "         LRWORK=-1), then on exit RWORK(1) contains the required length of",
       "         RWORK for the job parameters used in the call."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         Length of RWORK to confirm proper allocation of workspace.",
       "         LRWORK depends on the job:",
       "      1. If only the singular values are requested i.e. if",
       "         LSAME(JOBU,'N') .AND. LSAME(JOBV,'N')",
       "         then:",
       "         1.1. If LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G'),",
       "              then: LRWORK = max( 7, 2 * M ).",
       "         1.2. Otherwise, LRWORK  = max( 7,  N ).",
       "      2. If singular values with the right singular vectors are requested",
       "         i.e. if",
       "         (LSAME(JOBV,'V').OR.LSAME(JOBV,'J')) .AND.",
       "         .NOT.(LSAME(JOBU,'U').OR.LSAME(JOBU,'F'))",
       "         then:",
       "         2.1. If LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G'),",
       "         then LRWORK = max( 7, 2 * M ).",
       "         2.2. Otherwise, LRWORK  = max( 7,  N ).",
       "      3. If singular values with the left singular vectors are requested, i.e. if",
       "         (LSAME(JOBU,'U').OR.LSAME(JOBU,'F')) .AND.",
       "         .NOT.(LSAME(JOBV,'V').OR.LSAME(JOBV,'J'))",
       "         then:",
       "         3.1. If LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G'),",
       "         then LRWORK = max( 7, 2 * M ).",
       "         3.2. Otherwise, LRWORK  = max( 7,  N ).",
       "      4. If singular values with both the left and the right singular vectors",
       "         are requested, i.e. if",
       "         (LSAME(JOBU,'U').OR.LSAME(JOBU,'F')) .AND.",
       "         (LSAME(JOBV,'V').OR.LSAME(JOBV,'J'))",
       "         then:",
       "         4.1. If LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G'),",
       "         then LRWORK = max( 7, 2 * M ).",
       "         4.2. Otherwise, LRWORK  = max( 7, N ).",
       "         If, on entry, LRWORK = -1 ot LWORK=-1, a workspace query is assumed and ",
       "         the length of RWORK is returned in RWORK(1). "],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, of dimension at least 4, that further depends ",
       "         on the job:",
       "         1. If only the singular values are requested then:",
       "            If ( LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G') ) ",
       "            then the length of IWORK is N+M; otherwise the length of IWORK is N.",
       "         2. If the singular values and the right singular vectors are requested then:",
       "            If ( LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G') ) ",
       "            then the length of IWORK is N+M; otherwise the length of IWORK is N. ",
       "         3. If the singular values and the left singular vectors are requested then:",
       "            If ( LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G') ) ",
       "            then the length of IWORK is N+M; otherwise the length of IWORK is N. ",
       "         4. If the singular values with both the left and the right singular vectors",
       "            are requested, then:      ",
       "            4.1. If LSAME(JOBV,'J') the length of IWORK is determined as follows:",
       "                 If ( LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G') ) ",
       "                 then the length of IWORK is N+M; otherwise the length of IWORK is N. ",
       "            4.2. If LSAME(JOBV,'V') the length of IWORK is determined as follows:",
       "                 If ( LSAME(JOBT,'T') .OR. LSAME(JOBA,'F') .OR. LSAME(JOBA,'G') ) ",
       "                 then the length of IWORK is 2*N+M; otherwise the length of IWORK is 2*N.",
       "       ",
       "         On exit,",
       "         IWORK(1) = the numerical rank determined after the initial",
       "                    QR factorization with pivoting. See the descriptions",
       "                    of JOBA and JOBR.",
       "         IWORK(2) = the number of the computed nonzero singular values",
       "         IWORK(3) = if nonzero, a warning message:",
       "                    If IWORK(3).EQ.1 then some of the column norms of A",
       "                    were denormalized floats. The requested high accuracy",
       "                    is not warranted by the data.",
       "         IWORK(4) = 1 or -1. If IWORK(4) .EQ. 1, then the procedure used A^* to",
       "                    do the job as specified by the JOB parameters.",
       "         If the call to ZGEJSV is a workspace query (indicated by LWORK .EQ. -1 or",
       "         LRWORK .EQ. -1), then on exit IWORK(1) contains the required length of ",
       "         IWORK for the job parameters used in the call."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          < 0  : if INFO = -i, then the i-th argument had an illegal value.",
       "          = 0 :  successful exit;",
       "          > 0 :  ZGEJSV  did not converge in the maximal allowed number",
       "                 of sweeps. The computed values may be inaccurate."]}},
 "dorgrq"=>
  {"summary"=>
    ["DORGRQ generates an M-by-N real matrix Q with orthonormal rows,",
     "which is defined as the last M rows of a product of K elementary",
     "reflectors of order N",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by DGERQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the (m-k+i)-th row must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by DGERQF in the last k rows of its array argument",
       "         A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGERQF."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "ctrevc"=>
  {"summary"=>
    ["CTREVC computes some or all of the right and/or left eigenvectors of",
     "a complex upper triangular matrix T.",
     "Matrices of this type are produced by the Schur factorization of",
     "a complex general matrix:  A = Q*T*Q**H, as computed by CHSEQR.",
     "The right eigenvector x and the left eigenvector y of T corresponding",
     "to an eigenvalue w are defined by:",
     "             T*x = w*x,     (y**H)*T = w*(y**H)",
     "where y**H denotes the conjugate transpose of the vector y.",
     "The eigenvalues are not input to this routine, but are read directly",
     "from the diagonal of T.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an",
     "input matrix.  If Q is the unitary factor that reduces a matrix A to",
     "Schur form T, then Q*X and Q*Y are the matrices of right and left",
     "eigenvectors of A."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  compute right eigenvectors only;",
       "         = 'L':  compute left eigenvectors only;",
       "         = 'B':  compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A':  compute all right and/or left eigenvectors;",
       "         = 'B':  compute all right and/or left eigenvectors,",
       "                 backtransformed using the matrices supplied in",
       "                 VR and/or VL;",
       "         = 'S':  compute selected right and/or left eigenvectors,",
       "                 as indicated by the logical array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenvectors to be",
       "         computed.",
       "         The eigenvector corresponding to the j-th eigenvalue is",
       "         computed if SELECT(j) = .TRUE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in,out]",
       "         T is COMPLEX array, dimension (LDT,N)",
       "         The upper triangular matrix T.  T is modified, but restored",
       "         on exit."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is COMPLEX array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Q of",
       "         Schur vectors returned by CHSEQR).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VL, in the same order as their",
       "                          eigenvalues.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1, and if",
       "         SIDE = 'L' or 'B', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is COMPLEX array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Q of",
       "         Schur vectors returned by CHSEQR).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*X;",
       "         if HOWMNY = 'S', the right eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VR, in the same order as their",
       "                          eigenvalues.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1, and if",
       "         SIDE = 'R' or 'B'; LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.  If HOWMNY = 'A' or 'B', M",
       "         is set to N.  Each selected eigenvector occupies one",
       "         column."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgttrf"=>
  {"summary"=>
    ["DGTTRF computes an LU factorization of a real tridiagonal matrix A",
     "using elimination with partial pivoting and row interchanges.",
     "The factorization has the form",
     "   A = L * U",
     "where L is a product of permutation and unit lower bidiagonal",
     "matrices and U is upper triangular with nonzeros in only the main",
     "diagonal and first two superdiagonals."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "DL"=>
      ["[in,out]",
       "         DL is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, DL must contain the (n-1) sub-diagonal elements of",
       "         A.",
       "         On exit, DL is overwritten by the (n-1) multipliers that",
       "         define the matrix L from the LU factorization of A."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, D must contain the diagonal elements of A.",
       "         On exit, D is overwritten by the n diagonal elements of the",
       "         upper triangular matrix U from the LU factorization of A."],
     "DU"=>
      ["[in,out]",
       "         DU is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, DU must contain the (n-1) super-diagonal elements",
       "         of A.",
       "         On exit, DU is overwritten by the (n-1) elements of the first",
       "         super-diagonal of U."],
     "DU2"=>
      ["[out]",
       "         DU2 is DOUBLE PRECISION array, dimension (N-2)",
       "         On exit, DU2 is overwritten by the (n-2) elements of the",
       "         second super-diagonal of U."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value",
       "         > 0:  if INFO = k, U(k,k) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "ssytri2"=>
  {"summary"=>
    ["SSYTRI2 computes the inverse of a REAL symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "SSYTRF. SSYTRI2 sets the LEADING DIMENSION of the workspace",
     "before calling SSYTRI2X that actually computes the inverse."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by SSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NB structure of D",
       "         as determined by SSYTRF."],
     "WORK"=>
      ["[out]", "         WORK is REAL array, dimension (N+NB+1)*(NB+3)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         WORK is size >= (N+NB+1)*(NB+3)",
       "         If LDWORK = -1, then a workspace query is assumed; the routine",
       "          calculates:",
       "             - the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array,",
       "             - and no error message related to LDWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "sormql"=>
  {"summary"=>
    ["SORMQL overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by SGEQLF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         SGEQLF in the last k columns of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGEQLF."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slarscl2"=>
  {"summary"=>
    ["SLARSCL2 performs a reciprocal diagonal scaling on an vector:",
     "  x <-- inv(D) * x",
     "where the diagonal matrix D is stored as a vector.",
     "Eventually to be replaced by BLAS_sge_diag_scale in the new BLAS",
     "standard."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "    The number of rows of D and X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of columns of X. N >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, length M",
       "    Diagonal matrix D, stored as a vector of length M."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,N)",
       "    On entry, the vector X to be scaled by D.",
       "    On exit, the scaled vector."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the vector X. LDX >= M."]}},
 "chegs2"=>
  {"summary"=>
    ["CHEGS2 reduces a complex Hermitian-definite generalized",
     "eigenproblem to standard form.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H *A*L.",
     "B must have been previously factorized as U**H *U or L*L**H by ZPOTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H);",
       "         = 2 or 3: compute U*A*U**H or L**H *A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored, and how B has been factorized.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         as returned by CPOTRF."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "claed7"=>
  {"summary"=>
    ["CLAED7 computes the updated eigensystem of a diagonal",
     "matrix after modification by a rank-one symmetric matrix. This",
     "routine is used only for the eigenproblem which requires all",
     "eigenvalues and optionally eigenvectors of a dense or banded",
     "Hermitian matrix that has been reduced to tridiagonal form.",
     "  T = Q(in) ( D(in) + RHO * Z*Z**H ) Q**H(in) = Q(out) * D(out) * Q**H(out)",
     "  where Z = Q**Hu, u is a vector of length N with ones in the",
     "  CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.",
     "   The eigenvectors of the original matrix are stored in Q, and the",
     "   eigenvalues are in D.  The algorithm consists of three stages:",
     "      The first stage consists of deflating the size of the problem",
     "      when there are multiple eigenvalues or if there is a zero in",
     "      the Z vector.  For each such occurrence the dimension of the",
     "      secular equation problem is reduced by one.  This stage is",
     "      performed by the routine SLAED2.",
     "      The second stage consists of calculating the updated",
     "      eigenvalues. This is done by finding the roots of the secular",
     "      equation via the routine SLAED4 (as called by SLAED3).",
     "      This routine also calculates the eigenvectors of the current",
     "      problem.",
     "      The final stage consists of computing the updated eigenvectors",
     "      directly using the updated eigenvalues.  The eigenvectors for",
     "      the current problem are multiplied with the eigenvectors from",
     "      the overall problem."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "CUTPNT"=>
      ["[in]",
       "         CUTPNT is INTEGER",
       "        Contains the location of the last eigenvalue in the leading",
       "        sub-matrix.  min(1,N) <= CUTPNT <= N."],
     "QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the unitary matrix used to reduce",
       "        the full matrix to tridiagonal form.  QSIZ >= N."],
     "TLVLS"=>
      ["[in]",
       "         TLVLS is INTEGER",
       "        The total number of merging levels in the overall divide and",
       "        conquer tree."],
     "CURLVL"=>
      ["[in]",
       "         CURLVL is INTEGER",
       "        The current level in the overall merge routine,",
       "        0 <= curlvl <= tlvls."],
     "CURPBM"=>
      ["[in]",
       "         CURPBM is INTEGER",
       "        The current problem in the current level in the overall",
       "        merge routine (counting from upper left to lower right)."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry, the eigenvalues of the rank-1-perturbed matrix.",
       "        On exit, the eigenvalues of the repaired matrix."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDQ,N)",
       "        On entry, the eigenvectors of the rank-1-perturbed matrix.",
       "        On exit, the eigenvectors of the repaired tridiagonal matrix."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "RHO"=>
      ["[in]",
       "         RHO is REAL",
       "        Contains the subdiagonal element used to create the rank-1",
       "        modification."],
     "INDXQ"=>
      ["[out]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        This contains the permutation which will reintegrate the",
       "        subproblem just solved back into sorted order,",
       "        ie. D( INDXQ( I = 1, N ) ) will be in ascending order."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (4*N)"],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array,",
       "                                dimension (3*N+2*QSIZ*N)"],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (QSIZ*N)"],
     "QSTORE"=>
      ["[in,out]",
       "         QSTORE is REAL array, dimension (N**2+1)",
       "        Stores eigenvectors of submatrices encountered during",
       "        divide and conquer, packed together. QPTR points to",
       "        beginning of the submatrices."],
     "QPTR"=>
      ["[in,out]",
       "         QPTR is INTEGER array, dimension (N+2)",
       "        List of indices pointing to beginning of submatrices stored",
       "        in QSTORE. The submatrices are numbered starting at the",
       "        bottom left of the divide and conquer tree, from left to",
       "        right and bottom to top."],
     "PRMPTR"=>
      ["[in]",
       "         PRMPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in PERM a",
       "        level's permutation is stored.  PRMPTR(i+1) - PRMPTR(i)",
       "        indicates the size of the permutation and also the size of",
       "        the full, non-deflated problem."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension (N lg N)",
       "        Contains the permutations (from deflation and sorting) to be",
       "        applied to each eigenblock."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in GIVCOL a",
       "        level's Givens rotations are stored.  GIVPTR(i+1) - GIVPTR(i)",
       "        indicates the number of Givens rotations."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension (2, N lg N)",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is REAL array, dimension (2, N lg N)",
       "        Each number indicates the S value to be used in the",
       "        corresponding Givens rotation."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, an eigenvalue did not converge"]}},
 "chsein"=>
  {"summary"=>
    ["CHSEIN uses inverse iteration to find specified right and/or left",
     "eigenvectors of a complex upper Hessenberg matrix H.",
     "The right eigenvector x and the left eigenvector y of the matrix H",
     "corresponding to an eigenvalue w are defined by:",
     "             H * x = w * x,     y**h * H = w * y**h",
     "where y**h denotes the conjugate transpose of the vector y."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R': compute right eigenvectors only;",
       "         = 'L': compute left eigenvectors only;",
       "         = 'B': compute both right and left eigenvectors."],
     "EIGSRC"=>
      ["[in]",
       "         EIGSRC is CHARACTER*1",
       "         Specifies the source of eigenvalues supplied in W:",
       "         = 'Q': the eigenvalues were found using CHSEQR; thus, if",
       "                H has zero subdiagonal elements, and so is",
       "                block-triangular, then the j-th eigenvalue can be",
       "                assumed to be an eigenvalue of the block containing",
       "                the j-th row/column.  This property allows CHSEIN to",
       "                perform inverse iteration on just one diagonal block.",
       "         = 'N': no assumptions are made on the correspondence",
       "                between eigenvalues and diagonal blocks.  In this",
       "                case, CHSEIN must always perform inverse iteration",
       "                using the whole matrix H."],
     "INITV"=>
      ["[in]",
       "         INITV is CHARACTER*1",
       "         = 'N': no initial vectors are supplied;",
       "         = 'U': user-supplied initial vectors are stored in the arrays",
       "                VL and/or VR."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         Specifies the eigenvectors to be computed. To select the",
       "         eigenvector corresponding to the eigenvalue W(j),",
       "         SELECT(j) must be set to .TRUE.."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "H"=>
      ["[in]",
       "         H is COMPLEX array, dimension (LDH,N)",
       "         The upper Hessenberg matrix H.",
       "         If a NaN is detected in H, the routine will return with INFO=-6."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max(1,N)."],
     "W"=>
      ["[in,out]",
       "         W is COMPLEX array, dimension (N)",
       "         On entry, the eigenvalues of H.",
       "         On exit, the real parts of W may have been altered since",
       "         close eigenvalues are perturbed slightly in searching for",
       "         independent eigenvectors."],
     "VL"=>
      ["[in,out]",
       "         VL is COMPLEX array, dimension (LDVL,MM)",
       "         On entry, if INITV = 'U' and SIDE = 'L' or 'B', VL must",
       "         contain starting vectors for the inverse iteration for the",
       "         left eigenvectors; the starting vector for each eigenvector",
       "         must be in the same column in which the eigenvector will be",
       "         stored.",
       "         On exit, if SIDE = 'L' or 'B', the left eigenvectors",
       "         specified by SELECT will be stored consecutively in the",
       "         columns of VL, in the same order as their eigenvalues.",
       "         If SIDE = 'R', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= max(1,N) if SIDE = 'L' or 'B'; LDVL >= 1 otherwise."],
     "VR"=>
      ["[in,out]",
       "         VR is COMPLEX array, dimension (LDVR,MM)",
       "         On entry, if INITV = 'U' and SIDE = 'R' or 'B', VR must",
       "         contain starting vectors for the inverse iteration for the",
       "         right eigenvectors; the starting vector for each eigenvector",
       "         must be in the same column in which the eigenvector will be",
       "         stored.",
       "         On exit, if SIDE = 'R' or 'B', the right eigenvectors",
       "         specified by SELECT will be stored consecutively in the",
       "         columns of VR, in the same order as their eigenvalues.",
       "         If SIDE = 'L', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= max(1,N) if SIDE = 'R' or 'B'; LDVR >= 1 otherwise."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR required to",
       "         store the eigenvectors (= the number of .TRUE. elements in",
       "         SELECT)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "IFAILL"=>
      ["[out]",
       "         IFAILL is INTEGER array, dimension (MM)",
       "         If SIDE = 'L' or 'B', IFAILL(i) = j > 0 if the left",
       "         eigenvector in the i-th column of VL (corresponding to the",
       "         eigenvalue w(j)) failed to converge; IFAILL(i) = 0 if the",
       "         eigenvector converged satisfactorily.",
       "         If SIDE = 'R', IFAILL is not referenced."],
     "IFAILR"=>
      ["[out]",
       "         IFAILR is INTEGER array, dimension (MM)",
       "         If SIDE = 'R' or 'B', IFAILR(i) = j > 0 if the right",
       "         eigenvector in the i-th column of VR (corresponding to the",
       "         eigenvalue w(j)) failed to converge; IFAILR(i) = 0 if the",
       "         eigenvector converged satisfactorily.",
       "         If SIDE = 'L', IFAILR is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, i is the number of eigenvectors which",
       "               failed to converge; see IFAILL and IFAILR for further",
       "               details."]}},
 "dgbequ"=>
  {"summary"=>
    ["DGBEQU computes row and column scalings intended to equilibrate an",
     "M-by-N band matrix A and reduce its condition number.  R returns the",
     "row scale factors and C the column scale factors, chosen to try to",
     "make the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.",
     "R(i) and C(j) are restricted to be between SMLNUM = smallest safe",
     "number and BIGNUM = largest safe number.  Use of these scaling",
     "factors is not guaranteed to reduce the condition number of A but",
     "works well in practice."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The band matrix A, stored in rows 1 to KL+KU+1.  The j-th",
       "         column of A is stored in the j-th column of the array AB as",
       "         follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "R"=>
      ["[out]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         If INFO = 0, or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is DOUBLE PRECISION",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is DOUBLE PRECISION",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "cunbdb3"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M. M-P <= min(P,Q,M-Q)."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is REAL array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is COMPLEX array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is COMPLEX array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is COMPLEX array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dggesx"=>
  {"summary"=>
    ["DGGESX computes for a pair of N-by-N real nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, the real Schur form (S,T), and,",
     "optionally, the left and/or right matrices of Schur vectors (VSL and",
     "VSR).  This gives the generalized Schur factorization",
     "     (A,B) = ( (VSL) S (VSR)**T, (VSL) T (VSR)**T )",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "quasi-triangular matrix S and the upper triangular matrix T; computes",
     "a reciprocal condition number for the average of the selected",
     "eigenvalues (RCONDE); and computes a reciprocal condition number for",
     "the right and left deflating subspaces corresponding to the selected",
     "eigenvalues (RCONDV). The leading columns of VSL and VSR then form",
     "an orthonormal basis for the corresponding left and right eigenspaces",
     "(deflating subspaces).",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0 or for both being zero.",
     "A pair of matrices (S,T) is in generalized real Schur form if T is",
     "upper triangular with non-negative diagonal and S is block upper",
     "triangular with 1-by-1 and 2-by-2 blocks.  1-by-1 blocks correspond",
     "to real generalized eigenvalues, while 2-by-2 blocks of S will be",
     "\"standardized\" by making the corresponding elements of T have the",
     "form:",
     "        [  a  0  ]",
     "        [  0  b  ]",
     "and the pair of corresponding 2-by-2 blocks in S and T will have a",
     "complex conjugate pair of generalized eigenvalues."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG)."],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is procedure) LOGICAL FUNCTION of three DOUBLE PRECISION arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         An eigenvalue (ALPHAR(j)+ALPHAI(j))/BETA(j) is selected if",
       "         SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) is true; i.e. if either",
       "         one of a complex conjugate pair of eigenvalues is selected,",
       "         then both complex eigenvalues are selected.",
       "         Note that a selected complex eigenvalue may no longer satisfy",
       "         SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) = .TRUE. after ordering,",
       "         since ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned), in this",
       "         case INFO is set to N+3."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N' : None are computed;",
       "         = 'E' : Computed for average of selected eigenvalues only;",
       "         = 'V' : Computed for selected deflating subspaces only;",
       "         = 'B' : Computed for both.",
       "         If SENSE = 'E', 'V', or 'B', SORT must equal 'S'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true.  (Complex conjugate pairs for which",
       "         SELCTG is true for either eigenvalue count as 2.)"],
     "ALPHAR"=>
      ["[out]", "         ALPHAR is DOUBLE PRECISION array, dimension (N)"],
     "ALPHAI"=>
      ["[out]", "         ALPHAI is DOUBLE PRECISION array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  ALPHAR(j) + ALPHAI(j)*i",
       "         and BETA(j),j=1,...,N  are the diagonals of the complex Schur",
       "         form (S,T) that would result if the 2-by-2 diagonal blocks of",
       "         the real Schur form of (A,B) were further reduced to",
       "         triangular form using 2-by-2 complex unitary transformations.",
       "         If ALPHAI(j) is zero, then the j-th eigenvalue is real; if",
       "         positive, then the j-th and (j+1)-st eigenvalues are a",
       "         complex conjugate pair, with ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio.",
       "         However, ALPHAR and ALPHAI will be always less than and",
       "         usually comparable with norm(A) in magnitude, and BETA always",
       "         less than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is DOUBLE PRECISION array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >=1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is DOUBLE PRECISION array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is DOUBLE PRECISION array, dimension ( 2 )",
       "         If SENSE = 'E' or 'B', RCONDE(1) and RCONDE(2) contain the",
       "         reciprocal condition numbers for the average of the selected",
       "         eigenvalues.",
       "         Not referenced if SENSE = 'N' or 'V'."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is DOUBLE PRECISION array, dimension ( 2 )",
       "         If SENSE = 'V' or 'B', RCONDV(1) and RCONDV(2) contain the",
       "         reciprocal condition numbers for the selected deflating",
       "         subspaces.",
       "         Not referenced if SENSE = 'N' or 'E'."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N = 0, LWORK >= 1, else if SENSE = 'E', 'V', or 'B',",
       "         LWORK >= max( 8*N, 6*N+16, 2*SDIM*(N-SDIM) ), else",
       "         LWORK >= max( 8*N, 6*N+16 ).",
       "         Note that 2*SDIM*(N-SDIM) <= N*N/2.",
       "         Note also that an error is only returned if",
       "         LWORK < max( 8*N, 6*N+16), but if SENSE = 'E' or 'V' or 'B'",
       "         this may not be large enough.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the bound on the optimal size of the WORK",
       "         array and the minimum size of the IWORK array, returns these",
       "         values as the first entries of the WORK and IWORK arrays, and",
       "         no error message related to LWORK or LIWORK is issued by",
       "         XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If SENSE = 'N' or N = 0, LIWORK >= 1, otherwise",
       "         LIWORK >= N+6.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the bound on the optimal size of the",
       "         WORK array and the minimum size of the IWORK array, returns",
       "         these values as the first entries of the WORK and IWORK",
       "         arrays, and no error message related to LWORK or LIWORK is",
       "         issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHAR(j), ALPHAI(j), and BETA(j) should",
       "               be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in DHGEQZ",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in DTGSEN."]}},
 "sopmtr"=>
  {"summary"=>
    ["SOPMTR overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "nq-1 elementary reflectors, as returned by SSPTRD using packed",
     "storage:",
     "if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangular packed storage used in previous",
       "                call to SSPTRD;",
       "         = 'L': Lower triangular packed storage used in previous",
       "                call to SSPTRD."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension",
       "                              (M*(M+1)/2) if SIDE = 'L'",
       "                              (N*(N+1)/2) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by SSPTRD.  AP is modified by the routine but",
       "         restored on exit."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (M-1) if SIDE = 'L'",
       "                                    or (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SSPTRD."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension",
       "                                  (N) if SIDE = 'L'",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slasd0"=>
  {"summary"=>
    ["Using a divide and conquer approach, SLASD0 computes the singular",
     "value decomposition (SVD) of a real upper bidiagonal N-by-M",
     "matrix B with diagonal D and offdiagonal E, where M = N + SQRE.",
     "The algorithm computes orthogonal matrices U and VT such that",
     "B = U * S * VT. The singular values S are overwritten on D.",
     "A related subroutine, SLASDA, computes only the singular values,",
     "and optionally, the singular vectors in compact form."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        On entry, the row dimension of the upper bidiagonal matrix.",
       "        This is also the dimension of the main diagonal array D."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        Specifies the column dimension of the bidiagonal matrix.",
       "        = 0: The bidiagonal matrix has column dimension M = N;",
       "        = 1: The bidiagonal matrix has column dimension M = N+1;"],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry D contains the main diagonal of the bidiagonal",
       "        matrix.",
       "        On exit D, if INFO = 0, contains its singular values."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (M-1)",
       "        Contains the subdiagonal entries of the bidiagonal matrix.",
       "        On exit, E has been destroyed."],
     "U"=>
      ["[out]",
       "         U is REAL array, dimension at least (LDQ, N)",
       "        On exit, U contains the left singular vectors."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "        On entry, leading dimension of U."],
     "VT"=>
      ["[out]",
       "         VT is REAL array, dimension at least (LDVT, M)",
       "        On exit, VT**T contains the right singular vectors."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "        On entry, leading dimension of VT."],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        On entry, maximum size of the subproblems at the",
       "        bottom of the computation tree."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (8*N)"],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*M**2+2*M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, a singular value did not converge"]}},
 "cpftri"=>
  {"summary"=>
    ["CPFTRI computes the inverse of a complex Hermitian positive definite",
     "matrix A using the Cholesky factorization A = U**H*U or A = L*L**H",
     "computed by CPFTRF."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension ( N*(N+1)/2 );",
       "         On entry, the Hermitian matrix A in RFP format. RFP format is",
       "         described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'",
       "         then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'C' then RFP is",
       "         the Conjugate-transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the nt elements of",
       "         upper packed A. If UPLO = 'L' the RFP A contains the elements",
       "         of lower packed A. The LDA of RFP A is (N+1)/2 when TRANSR =",
       "         'C'. When TRANSR is 'N' the LDA is N+1 when N is even and N",
       "         is odd. See the Note below for more details.",
       "         On exit, the Hermitian inverse of the original matrix, in the",
       "         same storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "dlatdf"=>
  {"summary"=>
    ["DLATDF uses the LU factorization of the n-by-n matrix Z computed by",
     "DGETC2 and computes a contribution to the reciprocal Dif-estimate",
     "by solving Z * x = b for x, and choosing the r.h.s. b such that",
     "the norm of x is as large as possible. On entry RHS = b holds the",
     "contribution from earlier solved sub-systems, and on return RHS = x.",
     "The factorization of Z returned by DGETC2 has the form Z = P*L*U*Q,",
     "where P and Q are permutation matrices. L is lower triangular with",
     "unit diagonal elements and U is upper triangular."],
   "param"=>
    {"IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         IJOB = 2: First compute an approximative null-vector e",
       "             of Z using DGECON, e is normalized and solve for",
       "             Zx = +-e - f with the sign giving the greater value",
       "             of 2-norm(x). About 5 times as expensive as Default.",
       "         IJOB .ne. 2: Local look ahead strategy where all entries of",
       "             the r.h.s. b is chosen as either +1 or -1 (Default)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Z."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         On entry, the LU part of the factorization of the n-by-n",
       "         matrix Z computed by DGETC2:  Z = P * L * U * Q"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDA >= max(1, N)."],
     "RHS"=>
      ["[in,out]",
       "         RHS is DOUBLE PRECISION array, dimension (N)",
       "         On entry, RHS contains contributions from other subsystems.",
       "         On exit, RHS contains the solution of the subsystem with",
       "         entries acoording to the value of IJOB (see above)."],
     "RDSUM"=>
      ["[in,out]",
       "         RDSUM is DOUBLE PRECISION",
       "         On entry, the sum of squares of computed contributions to",
       "         the Dif-estimate under computation by DTGSYL, where the",
       "         scaling factor RDSCAL (see below) has been factored out.",
       "         On exit, the corresponding sum of squares updated with the",
       "         contributions from the current sub-system.",
       "         If TRANS = 'T' RDSUM is not touched.",
       "         NOTE: RDSUM only makes sense when DTGSY2 is called by STGSYL."],
     "RDSCAL"=>
      ["[in,out]",
       "         RDSCAL is DOUBLE PRECISION",
       "         On entry, scaling factor used to prevent overflow in RDSUM.",
       "         On exit, RDSCAL is updated w.r.t. the current contributions",
       "         in RDSUM.",
       "         If TRANS = 'T', RDSCAL is not touched.",
       "         NOTE: RDSCAL only makes sense when DTGSY2 is called by",
       "               DTGSYL."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[in]",
       "         JPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."]}},
 "zlaqsp"=>
  {"summary"=>
    ["ZLAQSP equilibrates a symmetric matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the equilibrated matrix:  diag(S) * A * diag(S), in",
       "         the same storage format as A."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is DOUBLE PRECISION",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "dtgsen"=>
  {"summary"=>
    ["DTGSEN reorders the generalized real Schur decomposition of a real",
     "matrix pair (A, B) (in terms of an orthonormal equivalence trans-",
     "formation Q**T * (A, B) * Z), so that a selected cluster of eigenvalues",
     "appears in the leading diagonal blocks of the upper quasi-triangular",
     "matrix A and the upper triangular B. The leading columns of Q and",
     "Z form orthonormal bases of the corresponding left and right eigen-",
     "spaces (deflating subspaces). (A, B) must be in generalized real",
     "Schur canonical form (as returned by DGGES), i.e. A is block upper",
     "triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper",
     "triangular.",
     "DTGSEN also computes the generalized eigenvalues",
     "            w(j) = (ALPHAR(j) + i*ALPHAI(j))/BETA(j)",
     "of the reordered matrix pair (A, B).",
     "Optionally, DTGSEN computes the estimates of reciprocal condition",
     "numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11),",
     "(A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s)",
     "between the matrix pairs (A11, B11) and (A22,B22) that correspond to",
     "the selected cluster and the eigenvalues outside the cluster, resp.,",
     "and norms of \"projections\" onto left and right eigenspaces w.r.t.",
     "the selected cluster in the (1,1)-block."],
   "param"=>
    {"IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies whether condition numbers are required for the",
       "         cluster of eigenvalues (PL and PR) or the deflating subspaces",
       "         (Difu and Difl):",
       "          =0: Only reorder w.r.t. SELECT. No extras.",
       "          =1: Reciprocal of norms of \"projections\" onto left and right",
       "              eigenspaces w.r.t. the selected cluster (PL and PR).",
       "          =2: Upper bounds on Difu and Difl. F-norm-based estimate",
       "              (DIF(1:2)).",
       "          =3: Estimate of Difu and Difl. 1-norm-based estimate",
       "              (DIF(1:2)).",
       "              About 5 times as expensive as IJOB = 2.",
       "          =4: Compute PL, PR and DIF (i.e. 0, 1 and 2 above): Economic",
       "              version to get it all.",
       "          =5: Compute PL, PR and DIF (i.e. 0, 1 and 3 above)"],
     "WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         SELECT specifies the eigenvalues in the selected cluster.",
       "         To select a real eigenvalue w(j), SELECT(j) must be set to",
       "         .TRUE.. To select a complex conjugate pair of eigenvalues",
       "         w(j) and w(j+1), corresponding to a 2-by-2 diagonal block,",
       "         either SELECT(j) or SELECT(j+1) or both must be set to",
       "         .TRUE.; a complex conjugate pair of eigenvalues must be",
       "         either both included in the cluster or both excluded."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension(LDA,N)",
       "         On entry, the upper quasi-triangular matrix A, with (A, B) in",
       "         generalized real Schur canonical form.",
       "         On exit, A is overwritten by the reordered matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension(LDB,N)",
       "         On entry, the upper triangular matrix B, with (A, B) in",
       "         generalized real Schur canonical form.",
       "         On exit, B is overwritten by the reordered matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "ALPHAR"=>
      ["[out]", "         ALPHAR is DOUBLE PRECISION array, dimension (N)"],
     "ALPHAI"=>
      ["[out]", "         ALPHAI is DOUBLE PRECISION array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  ALPHAR(j) + ALPHAI(j)*i",
       "         and BETA(j),j=1,...,N  are the diagonals of the complex Schur",
       "         form (S,T) that would result if the 2-by-2 diagonal blocks of",
       "         the real generalized Schur form of (A,B) were further reduced",
       "         to triangular form using complex unitary transformations.",
       "         If ALPHAI(j) is zero, then the j-th eigenvalue is real; if",
       "         positive, then the j-th and (j+1)-st eigenvalues are a",
       "         complex conjugate pair, with ALPHAI(j+1) negative."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         On entry, if WANTQ = .TRUE., Q is an N-by-N matrix.",
       "         On exit, Q has been postmultiplied by the left orthogonal",
       "         transformation matrix which reorder (A, B); The leading M",
       "         columns of Q form orthonormal bases for the specified pair of",
       "         left eigenspaces (deflating subspaces).",
       "         If WANTQ = .FALSE., Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= 1;",
       "         and if WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ,N)",
       "         On entry, if WANTZ = .TRUE., Z is an N-by-N matrix.",
       "         On exit, Z has been postmultiplied by the left orthogonal",
       "         transformation matrix which reorder (A, B); The leading M",
       "         columns of Z form orthonormal bases for the specified pair of",
       "         left eigenspaces (deflating subspaces).",
       "         If WANTZ = .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1;",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The dimension of the specified pair of left and right eigen-",
       "         spaces (deflating subspaces). 0 <= M <= N."],
     "PL"=>["[out]", "         PL is DOUBLE PRECISION"],
     "PR"=>
      ["[out]",
       "         PR is DOUBLE PRECISION",
       "         If IJOB = 1, 4 or 5, PL, PR are lower bounds on the",
       "         reciprocal of the norm of \"projections\" onto left and right",
       "         eigenspaces with respect to the selected cluster.",
       "         0 < PL, PR <= 1.",
       "         If M = 0 or M = N, PL = PR  = 1.",
       "         If IJOB = 0, 2 or 3, PL and PR are not referenced."],
     "DIF"=>
      ["[out]",
       "         DIF is DOUBLE PRECISION array, dimension (2).",
       "         If IJOB >= 2, DIF(1:2) store the estimates of Difu and Difl.",
       "         If IJOB = 2 or 4, DIF(1:2) are F-norm-based upper bounds on",
       "         Difu and Difl. If IJOB = 3 or 5, DIF(1:2) are 1-norm-based",
       "         estimates of Difu and Difl.",
       "         If M = 0 or N, DIF(1:2) = F-norm([A, B]).",
       "         If IJOB = 0 or 1, DIF is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array,",
       "         dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >=  4*N+16.",
       "         If IJOB = 1, 2 or 4, LWORK >= MAX(4*N+16, 2*M*(N-M)).",
       "         If IJOB = 3 or 5, LWORK >= MAX(4*N+16, 4*M*(N-M)).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK. LIWORK >= 1.",
       "         If IJOB = 1, 2 or 4, LIWORK >=  N+6.",
       "         If IJOB = 3 or 5, LIWORK >= MAX(2*M*(N-M), N+6).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "           =0: Successful exit.",
       "           <0: If INFO = -i, the i-th argument had an illegal value.",
       "           =1: Reordering of (A, B) failed because the transformed",
       "               matrix pair (A, B) would be too far from generalized",
       "               Schur form; the problem is very ill-conditioned.",
       "               (A, B) may have been partially reordered.",
       "               If requested, 0 is returned in DIF(*), PL and PR."]}},
 "zstein"=>
  {"summary"=>
    ["ZSTEIN computes the eigenvectors of a real symmetric tridiagonal",
     "matrix T corresponding to specified eigenvalues, using inverse",
     "iteration.",
     "The maximum number of iterations allowed for each eigenvector is",
     "specified by an internal parameter MAXITS (currently set to 5).",
     "Although the eigenvectors are real, they are stored in a complex",
     "array, which may be passed to ZUNMTR or ZUPMTR for back",
     "transformation to the eigenvectors of a complex Hermitian matrix",
     "which was reduced to tridiagonal form."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the tridiagonal matrix",
       "         T, stored in elements 1 to N-1."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of eigenvectors to be found.  0 <= M <= N."],
     "W"=>
      ["[in]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements of W contain the eigenvalues for",
       "         which eigenvectors are to be computed.  The eigenvalues",
       "         should be grouped by split-off block and ordered from",
       "         smallest to largest within the block.  ( The output array",
       "         W from DSTEBZ with ORDER = 'B' is expected here. )"],
     "IBLOCK"=>
      ["[in]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         The submatrix indices associated with the corresponding",
       "         eigenvalues in W; IBLOCK(i)=1 if eigenvalue W(i) belongs to",
       "         the first submatrix from the top, =2 if W(i) belongs to",
       "         the second submatrix, etc.  ( The output array IBLOCK",
       "         from DSTEBZ is expected here. )"],
     "ISPLIT"=>
      ["[in]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into submatrices.",
       "         The first submatrix consists of rows/columns 1 to",
       "         ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1",
       "         through ISPLIT( 2 ), etc.",
       "         ( The output array ISPLIT from DSTEBZ is expected here. )"],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, M)",
       "         The computed eigenvectors.  The eigenvector associated",
       "         with the eigenvalue W(i) is stored in the i-th column of",
       "         Z.  Any vector which fails to converge is set to its current",
       "         iterate after MAXITS iterations.",
       "         The imaginary parts of the eigenvectors are set to zero."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (5*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (M)",
       "         On normal exit, all elements of IFAIL are zero.",
       "         If one or more eigenvectors fail to converge after",
       "         MAXITS iterations, then their indices are stored in",
       "         array IFAIL."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, then i eigenvectors failed to converge",
       "              in MAXITS iterations.  Their indices are stored in",
       "              array IFAIL."]}},
 "clarf"=>
  {"summary"=>
    ["CLARF applies a complex elementary reflector H to a complex M-by-N",
     "matrix C, from either the left or the right. H is represented in the",
     "form",
     "      H = I - tau * v * v**H",
     "where tau is a complex scalar and v is a complex vector.",
     "If tau = 0, then H is taken to be the unit matrix.",
     "To apply H**H (the conjugate transpose of H), supply conjg(tau) instead",
     "tau."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension",
       "                    (1 + (M-1)*abs(INCV)) if SIDE = 'L'",
       "                 or (1 + (N-1)*abs(INCV)) if SIDE = 'R'",
       "         The vector v in the representation of H. V is not used if",
       "         TAU = 0."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between elements of v. INCV <> 0."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension",
       "                        (N) if SIDE = 'L'",
       "                     or (M) if SIDE = 'R'"]}},
 "sorbdb6"=>
  {"summary"=>[],
   "param"=>
    {"M1"=>
      ["[in]",
       "         M1 is INTEGER",
       "          The dimension of X1 and the number of rows in Q1. 0 <= M1."],
     "M2"=>
      ["[in]",
       "         M2 is INTEGER",
       "          The dimension of X2 and the number of rows in Q2. 0 <= M2."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The number of columns in Q1 and Q2. 0 <= N."],
     "X1"=>
      ["[in,out]",
       "         X1 is REAL array, dimension (M1)",
       "          On entry, the top part of the vector to be orthogonalized.",
       "          On exit, the top part of the projected vector."],
     "INCX1"=>
      ["[in]",
       "         INCX1 is INTEGER",
       "          Increment for entries of X1."],
     "X2"=>
      ["[in,out]",
       "         X2 is REAL array, dimension (M2)",
       "          On entry, the bottom part of the vector to be",
       "          orthogonalized. On exit, the bottom part of the projected",
       "          vector."],
     "INCX2"=>
      ["[in]",
       "         INCX2 is INTEGER",
       "          Increment for entries of X2."],
     "Q1"=>
      ["[in]",
       "         Q1 is REAL array, dimension (LDQ1, N)",
       "          The top part of the orthonormal basis matrix."],
     "LDQ1"=>
      ["[in]",
       "         LDQ1 is INTEGER",
       "          The leading dimension of Q1. LDQ1 >= M1."],
     "Q2"=>
      ["[in]",
       "         Q2 is REAL array, dimension (LDQ2, N)",
       "          The bottom part of the orthonormal basis matrix."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "          The leading dimension of Q2. LDQ2 >= M2."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dorg2r"=>
  {"summary"=>
    ["DORG2R generates an m by n real matrix Q with orthonormal columns,",
     "which is defined as the first n columns of a product of k elementary",
     "reflectors of order m",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by DGEQRF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the i-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by DGEQRF in the first k columns of its array",
       "         argument A.",
       "         On exit, the m-by-n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGEQRF."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "ssygv_2stage"=>
  {"summary"=>
    ["SSYGV_2STAGE computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be symmetric and B is also",
     "positive definite.",
     "This routine use the 2stage technique for the reduction to tridiagonal",
     "which showed higher performance on recent architecture and for large"],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, the symmetric positive definite matrix B.",
       "         If UPLO = 'U', the leading N-by-N upper triangular part of B",
       "         contains the upper triangular part of the matrix B.",
       "         If UPLO = 'L', the leading N-by-N lower triangular part of B",
       "         contains the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + 2*N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + 2*N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  SPOTRF or SSYEV returned an error code:",
       "            <= N:  if INFO = i, SSYEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "ilazlc"=>
  {"summary"=>["ILAZLC scans A for its last non-zero column."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."]}},
 "zlascl2"=>
  {"summary"=>
    ["ZLASCL2 performs a diagonal scaling on a vector:",
     "  x <-- D * x",
     "where the DOUBLE PRECISION diagonal matrix D is stored as a vector.",
     "Eventually to be replaced by BLAS_zge_diag_scale in the new BLAS",
     "standard."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "    The number of rows of D and X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of columns of X. N >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, length M",
       "    Diagonal matrix D, stored as a vector of length M."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,N)",
       "    On entry, the vector X to be scaled by D.",
       "    On exit, the scaled vector."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the vector X. LDX >= M."]}},
 "csyrfsx"=>
  {"summary"=>
    ["   CSYRFSX improves the computed solution to a system of linear",
     "   equations when the coefficient matrix is symmetric indefinite, and",
     "   provides error bounds and backward error estimates for the",
     "   solution.  In addition to normwise error bound, the code provides",
     "   maximum componentwise error bound if possible.  See comments for",
     "   ERR_BNDS_NORM and ERR_BNDS_COMP for details of the error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED and S",
     "   below. In this case, the solution and error bounds returned are",
     "   for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'Y':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(S) * A * diag(S).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "    upper triangular part of A contains the upper triangular",
       "    part of the matrix A, and the strictly lower triangular",
       "    part of A is not referenced.  If UPLO = 'L', the leading",
       "    N-by-N lower triangular part of A contains the lower",
       "    triangular part of the matrix A, and the strictly upper",
       "    triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The factored form of the matrix A.  AF contains the block",
       "    diagonal matrix D and the multipliers used to obtain the",
       "    factor U or L from the factorization A = U*D*U**T or A =",
       "    L*D*L**T as computed by SSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by SSYTRF."],
     "S"=>
      ["[in,out]",
       "         S is REAL array, dimension (N)",
       "    The scale factors for A.  If EQUED = 'Y', A is multiplied on",
       "    the left and right by diag(S).  S is an input argument if FACT =",
       "    'F'; otherwise, S is an output argument.  If FACT = 'F' and EQUED",
       "    = 'Y', each element of S must be positive.  If S is output, each",
       "    element of S is a power of the radix. If S is input, each element",
       "    of S should be a power of the radix to ensure a reliable solution",
       "    and error estimates. Scaling by powers of the radix does not cause",
       "    rounding errors unless the result underflows or overflows.",
       "    Rounding errors during scaling lead to refining with a matrix that",
       "    is not equivalent to the input matrix, producing error estimates",
       "    that may not be reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by SGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is REAL array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "zhpgst"=>
  {"summary"=>
    ["ZHPGST reduces a complex Hermitian-definite generalized",
     "eigenproblem to standard form, using packed storage.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L.",
     "B must have been previously factorized as U**H*U or L*L**H by ZPPTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H);",
       "         = 2 or 3: compute U*A*U**H or L**H*A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored and B is factored as",
       "                 U**H*U;",
       "         = 'L':  Lower triangle of A is stored and B is factored as",
       "                 L*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "BP"=>
      ["[in]",
       "         BP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         stored in the same format as A, as returned by ZPPTRF."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zheevd"=>
  {"summary"=>
    ["ZHEEVD computes all eigenvalues and, optionally, eigenvectors of a",
     "complex Hermitian matrix A.  If eigenvectors are desired, it uses a",
     "divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.",
       "         If N <= 1,                LWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LWORK must be at least N + 1.",
       "         If JOBZ  = 'V' and N > 1, LWORK must be at least 2*N + N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array,",
       "                                        dimension (LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If N <= 1,                LRWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LRWORK must be at least N.",
       "         If JOBZ  = 'V' and N > 1, LRWORK must be at least",
       "                        1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i and JOBZ = 'N', then the algorithm failed",
       "               to converge; i off-diagonal elements of an intermediate",
       "               tridiagonal form did not converge to zero;",
       "               if INFO = i and JOBZ = 'V', then the algorithm failed",
       "               to compute an eigenvalue while working on the submatrix",
       "               lying in rows and columns INFO/(N+1) through",
       "               mod(INFO,N+1)."]}},
 "zhsein"=>
  {"summary"=>
    ["ZHSEIN uses inverse iteration to find specified right and/or left",
     "eigenvectors of a complex upper Hessenberg matrix H.",
     "The right eigenvector x and the left eigenvector y of the matrix H",
     "corresponding to an eigenvalue w are defined by:",
     "             H * x = w * x,     y**h * H = w * y**h",
     "where y**h denotes the conjugate transpose of the vector y."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R': compute right eigenvectors only;",
       "         = 'L': compute left eigenvectors only;",
       "         = 'B': compute both right and left eigenvectors."],
     "EIGSRC"=>
      ["[in]",
       "         EIGSRC is CHARACTER*1",
       "         Specifies the source of eigenvalues supplied in W:",
       "         = 'Q': the eigenvalues were found using ZHSEQR; thus, if",
       "                H has zero subdiagonal elements, and so is",
       "                block-triangular, then the j-th eigenvalue can be",
       "                assumed to be an eigenvalue of the block containing",
       "                the j-th row/column.  This property allows ZHSEIN to",
       "                perform inverse iteration on just one diagonal block.",
       "         = 'N': no assumptions are made on the correspondence",
       "                between eigenvalues and diagonal blocks.  In this",
       "                case, ZHSEIN must always perform inverse iteration",
       "                using the whole matrix H."],
     "INITV"=>
      ["[in]",
       "         INITV is CHARACTER*1",
       "         = 'N': no initial vectors are supplied;",
       "         = 'U': user-supplied initial vectors are stored in the arrays",
       "                VL and/or VR."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         Specifies the eigenvectors to be computed. To select the",
       "         eigenvector corresponding to the eigenvalue W(j),",
       "         SELECT(j) must be set to .TRUE.."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "H"=>
      ["[in]",
       "         H is COMPLEX*16 array, dimension (LDH,N)",
       "         The upper Hessenberg matrix H.",
       "         If a NaN is detected in H, the routine will return with INFO=-6."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max(1,N)."],
     "W"=>
      ["[in,out]",
       "         W is COMPLEX*16 array, dimension (N)",
       "         On entry, the eigenvalues of H.",
       "         On exit, the real parts of W may have been altered since",
       "         close eigenvalues are perturbed slightly in searching for",
       "         independent eigenvectors."],
     "VL"=>
      ["[in,out]",
       "         VL is COMPLEX*16 array, dimension (LDVL,MM)",
       "         On entry, if INITV = 'U' and SIDE = 'L' or 'B', VL must",
       "         contain starting vectors for the inverse iteration for the",
       "         left eigenvectors; the starting vector for each eigenvector",
       "         must be in the same column in which the eigenvector will be",
       "         stored.",
       "         On exit, if SIDE = 'L' or 'B', the left eigenvectors",
       "         specified by SELECT will be stored consecutively in the",
       "         columns of VL, in the same order as their eigenvalues.",
       "         If SIDE = 'R', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= max(1,N) if SIDE = 'L' or 'B'; LDVL >= 1 otherwise."],
     "VR"=>
      ["[in,out]",
       "         VR is COMPLEX*16 array, dimension (LDVR,MM)",
       "         On entry, if INITV = 'U' and SIDE = 'R' or 'B', VR must",
       "         contain starting vectors for the inverse iteration for the",
       "         right eigenvectors; the starting vector for each eigenvector",
       "         must be in the same column in which the eigenvector will be",
       "         stored.",
       "         On exit, if SIDE = 'R' or 'B', the right eigenvectors",
       "         specified by SELECT will be stored consecutively in the",
       "         columns of VR, in the same order as their eigenvalues.",
       "         If SIDE = 'L', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= max(1,N) if SIDE = 'R' or 'B'; LDVR >= 1 otherwise."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR required to",
       "         store the eigenvectors (= the number of .TRUE. elements in",
       "         SELECT)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "IFAILL"=>
      ["[out]",
       "         IFAILL is INTEGER array, dimension (MM)",
       "         If SIDE = 'L' or 'B', IFAILL(i) = j > 0 if the left",
       "         eigenvector in the i-th column of VL (corresponding to the",
       "         eigenvalue w(j)) failed to converge; IFAILL(i) = 0 if the",
       "         eigenvector converged satisfactorily.",
       "         If SIDE = 'R', IFAILL is not referenced."],
     "IFAILR"=>
      ["[out]",
       "         IFAILR is INTEGER array, dimension (MM)",
       "         If SIDE = 'R' or 'B', IFAILR(i) = j > 0 if the right",
       "         eigenvector in the i-th column of VR (corresponding to the",
       "         eigenvalue w(j)) failed to converge; IFAILR(i) = 0 if the",
       "         eigenvector converged satisfactorily.",
       "         If SIDE = 'L', IFAILR is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, i is the number of eigenvectors which",
       "               failed to converge; see IFAILL and IFAILR for further",
       "               details."]}},
 "cptsv"=>
  {"summary"=>
    ["CPTSV computes the solution to a complex system of linear equations",
     "A*X = B, where A is an N-by-N Hermitian positive definite tridiagonal",
     "matrix, and X and B are N-by-NRHS matrices.",
     "A is factored as A = L*D*L**H, and the factored form of A is then",
     "used to solve the system of equations."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.  On exit, the n diagonal elements of the diagonal matrix",
       "         D from the factorization A = L*D*L**H."],
     "E"=>
      ["[in,out]",
       "         E is COMPLEX array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A.  On exit, the (n-1) subdiagonal elements of the",
       "         unit bidiagonal factor L from the L*D*L**H factorization of",
       "         A.  E can also be regarded as the superdiagonal of the unit",
       "         bidiagonal factor U from the U**H*D*U factorization of A."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the solution has not been",
       "               computed.  The factorization has not been completed",
       "               unless i = N."]}},
 "zlantp"=>
  {"summary"=>
    ["ZLANTP  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "triangular matrix A, supplied in packed form.",
     "   ZLANTP = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANTP as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANTP is",
       "         set to zero."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         Note that when DIAG = 'U', the elements of the array AP",
       "         corresponding to the diagonal elements of the matrix A are",
       "         not referenced, but are assumed to be one."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "zungql"=>
  {"summary"=>
    ["ZUNGQL generates an M-by-N complex matrix Q with orthonormal columns,",
     "which is defined as the last N columns of a product of K elementary",
     "reflectors of order M",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by ZGEQLF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the (n-k+i)-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by ZGEQLF in the last k columns of its array",
       "         argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGEQLF."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "dptsvx"=>
  {"summary"=>
    ["DPTSVX uses the factorization A = L*D*L**T to compute the solution",
     "to a real system of linear equations A*X = B, where A is an N-by-N",
     "symmetric positive definite tridiagonal matrix and X and B are",
     "N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "cunbdb5"=>
  {"summary"=>[],
   "param"=>
    {"M1"=>
      ["[in]",
       "         M1 is INTEGER",
       "          The dimension of X1 and the number of rows in Q1. 0 <= M1."],
     "M2"=>
      ["[in]",
       "         M2 is INTEGER",
       "          The dimension of X2 and the number of rows in Q2. 0 <= M2."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The number of columns in Q1 and Q2. 0 <= N."],
     "X1"=>
      ["[in,out]",
       "         X1 is COMPLEX array, dimension (M1)",
       "          On entry, the top part of the vector to be orthogonalized.",
       "          On exit, the top part of the projected vector."],
     "INCX1"=>
      ["[in]",
       "         INCX1 is INTEGER",
       "          Increment for entries of X1."],
     "X2"=>
      ["[in,out]",
       "         X2 is COMPLEX array, dimension (M2)",
       "          On entry, the bottom part of the vector to be",
       "          orthogonalized. On exit, the bottom part of the projected",
       "          vector."],
     "INCX2"=>
      ["[in]",
       "         INCX2 is INTEGER",
       "          Increment for entries of X2."],
     "Q1"=>
      ["[in]",
       "         Q1 is COMPLEX array, dimension (LDQ1, N)",
       "          The top part of the orthonormal basis matrix."],
     "LDQ1"=>
      ["[in]",
       "         LDQ1 is INTEGER",
       "          The leading dimension of Q1. LDQ1 >= M1."],
     "Q2"=>
      ["[in]",
       "         Q2 is COMPLEX array, dimension (LDQ2, N)",
       "          The bottom part of the orthonormal basis matrix."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "          The leading dimension of Q2. LDQ2 >= M2."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "sorbdb1"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <=",
       "          MIN(P,M-P,M-Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is REAL array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is REAL array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is REAL array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is REAL array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is REAL array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is REAL array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "chfrk"=>
  {"summary"=>
    ["Level 3 BLAS like routine for C in RFP Format.",
     "CHFRK performs one of the Hermitian rank--k operations",
     "   C := alpha*A*A**H + beta*C,",
     "or",
     "   C := alpha*A**H*A + beta*C,",
     "where alpha and beta are real scalars, C is an n--by--n Hermitian",
     "matrix and A is an n--by--k matrix in the first case and a k--by--n",
     "matrix in the second case."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal Form of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose Form of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On  entry,   UPLO  specifies  whether  the  upper  or  lower",
       "          triangular  part  of the  array  C  is to be  referenced  as",
       "          follows:",
       "             UPLO = 'U' or 'u'   Only the  upper triangular part of  C",
       "                                 is to be referenced.",
       "             UPLO = 'L' or 'l'   Only the  lower triangular part of  C",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "          On entry,  TRANS  specifies the operation to be performed as",
       "          follows:",
       "             TRANS = 'N' or 'n'   C := alpha*A*A**H + beta*C.",
       "             TRANS = 'C' or 'c'   C := alpha*A**H*A + beta*C.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry,  N specifies the order of the matrix C.  N must be",
       "          at least zero.",
       "          Unchanged on exit."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "          On entry with  TRANS = 'N' or 'n',  K  specifies  the number",
       "          of  columns   of  the   matrix   A,   and  on   entry   with",
       "          TRANS = 'C' or 'c',  K  specifies  the number of rows of the",
       "          matrix A.  K must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,ka)",
       "          where KA",
       "          is K  when TRANS = 'N' or 'n', and is N otherwise. Before",
       "          entry with TRANS = 'N' or 'n', the leading N--by--K part of",
       "          the array A must contain the matrix A, otherwise the leading",
       "          K--by--N part of the array A must contain the matrix A.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'",
       "          then  LDA must be at least  max( 1, n ), otherwise  LDA must",
       "          be at least  max( 1, k ).",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL",
       "          On entry, BETA specifies the scalar beta.",
       "          Unchanged on exit."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (N*(N+1)/2)",
       "          On entry, the matrix A in RFP Format. RFP Format is",
       "          described by TRANSR, UPLO and N. Note that the imaginary",
       "          parts of the diagonal elements need not be set, they are",
       "          assumed to be zero, and on exit they are set to zero."]}},
 "sgehrd"=>
  {"summary"=>
    ["SGEHRD reduces a real general matrix A to upper Hessenberg form H by",
     "an orthogonal similarity transformation:  Q**T * A * Q = H ."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that A is already upper triangular in rows",
       "         and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "         set by a previous call to SGEBAL; otherwise they should be",
       "         set to 1 and N respectively. See Further Details.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         elements below the first subdiagonal, with the array TAU,",
       "         represent the orthogonal matrix Q as a product of elementary",
       "         reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details). Elements 1:ILO-1 and IHI:N-1 of TAU are set to",
       "         zero."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,N).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zlalsa"=>
  {"summary"=>
    ["ZLALSA is an itermediate step in solving the least squares problem",
     "by computing the SVD of the coefficient matrix in compact form (The",
     "singular vectors are computed as products of simple orthorgonal",
     "matrices.).",
     "If ICOMPQ = 0, ZLALSA applies the inverse of the left singular vector",
     "matrix of an upper bidiagonal matrix to the right hand side; and if",
     "ICOMPQ = 1, ZLALSA applies the right singular vector matrix to the",
     "right hand side. The singular vector matrices were generated in",
     "compact form by ZLALSA."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether the left or the right singular vector",
       "        matrix is involved.",
       "        = 0: Left singular vector matrix",
       "        = 1: Right singular vector matrix"],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        The maximum size of the subproblems at the bottom of the",
       "        computation tree."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The row and column dimensions of the upper bidiagonal matrix."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B and BX. NRHS must be at least 1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension ( LDB, NRHS )",
       "        On input, B contains the right hand sides of the least",
       "        squares problem in rows 1 through M.",
       "        On output, B contains the solution X in rows 1 through N."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B in the calling subprogram.",
       "        LDB must be at least max(1,MAX( M, N ) )."],
     "BX"=>
      ["[out]",
       "         BX is COMPLEX*16 array, dimension ( LDBX, NRHS )",
       "        On exit, the result of applying the left or right singular",
       "        vector matrix to B."],
     "LDBX"=>
      ["[in]",
       "         LDBX is INTEGER",
       "        The leading dimension of BX."],
     "U"=>
      ["[in]",
       "         U is DOUBLE PRECISION array, dimension ( LDU, SMLSIZ ).",
       "        On entry, U contains the left singular vector matrices of all",
       "        subproblems at the bottom level."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER, LDU = > N.",
       "        The leading dimension of arrays U, VT, DIFL, DIFR,",
       "        POLES, GIVNUM, and Z."],
     "VT"=>
      ["[in]",
       "         VT is DOUBLE PRECISION array, dimension ( LDU, SMLSIZ+1 ).",
       "        On entry, VT**H contains the right singular vector matrices of",
       "        all subproblems at the bottom level."],
     "K"=>["[in]", "         K is INTEGER array, dimension ( N )."],
     "DIFL"=>
      ["[in]",
       "         DIFL is DOUBLE PRECISION array, dimension ( LDU, NLVL ).",
       "        where NLVL = INT(log_2 (N/(SMLSIZ+1))) + 1."],
     "DIFR"=>
      ["[in]",
       "         DIFR is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, DIFL(*, I) and DIFR(*, 2 * I -1) record",
       "        distances between singular values on the I-th level and",
       "        singular values on the (I -1)-th level, and DIFR(*, 2 * I)",
       "        record the normalizing factors of the right singular vectors",
       "        matrices of subproblems on I-th level."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension ( LDU, NLVL ).",
       "        On entry, Z(1, I) contains the components of the deflation-",
       "        adjusted updating row vector for subproblems on the I-th",
       "        level."],
     "POLES"=>
      ["[in]",
       "         POLES is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, POLES(*, 2 * I -1: 2 * I) contains the new and old",
       "        singular values involved in the secular equations on the I-th",
       "        level."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER array, dimension ( N ).",
       "        On entry, GIVPTR( I ) records the number of Givens",
       "        rotations performed on the I-th problem on the computation",
       "        tree."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 * NLVL ).",
       "        On entry, for each I, GIVCOL(*, 2 * I - 1: 2 * I) records the",
       "        locations of Givens rotations performed on the I-th level on",
       "        the computation tree."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER, LDGCOL = > N.",
       "        The leading dimension of arrays GIVCOL and PERM."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension ( LDGCOL, NLVL ).",
       "        On entry, PERM(*, I) records permutations done on the I-th",
       "        level of the computation tree."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, GIVNUM(*, 2 *I -1 : 2 * I) records the C- and S-",
       "        values of Givens rotations performed on the I-th level on the",
       "        computation tree."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension ( N ).",
       "        On entry, if the I-th subproblem is not square,",
       "        C( I ) contains the C-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension ( N ).",
       "        On entry, if the I-th subproblem is not square,",
       "        S( I ) contains the S-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension at least",
       "        MAX( (SMLSZ+1)*NRHS*3, N*(1+NRHS) + 2*NRHS )."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array.",
       "        The dimension must be at least 3 * N"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "cunmql"=>
  {"summary"=>
    ["CUNMQL overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by CGEQLF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGEQLF in the last k columns of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGEQLF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhetd2"=>
  {"summary"=>
    ["ZHETD2 reduces a complex Hermitian matrix A to real symmetric",
     "tridiagonal form T by a unitary similarity transformation:",
     "Q**H * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the unitary",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the unitary matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zgelq2"=>
  {"summary"=>
    ["ZGELQ2 computes an LQ factorization of a complex m by n matrix A:",
     "A = L * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the m by min(m,n) lower trapezoidal matrix L (L is",
       "         lower triangular if m <= n); the elements above the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "slaeda"=>
  {"summary"=>
    ["SLAEDA computes the Z vector corresponding to the merge step in the",
     "CURLVLth step of the merge process with TLVLS steps for the CURPBMth",
     "problem."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "TLVLS"=>
      ["[in]",
       "         TLVLS is INTEGER",
       "        The total number of merging levels in the overall divide and",
       "        conquer tree."],
     "CURLVL"=>
      ["[in]",
       "         CURLVL is INTEGER",
       "        The current level in the overall merge routine,",
       "        0 <= curlvl <= tlvls."],
     "CURPBM"=>
      ["[in]",
       "         CURPBM is INTEGER",
       "        The current problem in the current level in the overall",
       "        merge routine (counting from upper left to lower right)."],
     "PRMPTR"=>
      ["[in]",
       "         PRMPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in PERM a",
       "        level's permutation is stored.  PRMPTR(i+1) - PRMPTR(i)",
       "        indicates the size of the permutation and incidentally the",
       "        size of the full, non-deflated problem."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension (N lg N)",
       "        Contains the permutations (from deflation and sorting) to be",
       "        applied to each eigenblock."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in GIVCOL a",
       "        level's Givens rotations are stored.  GIVPTR(i+1) - GIVPTR(i)",
       "        indicates the number of Givens rotations."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension (2, N lg N)",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is REAL array, dimension (2, N lg N)",
       "        Each number indicates the S value to be used in the",
       "        corresponding Givens rotation."],
     "Q"=>
      ["[in]",
       "         Q is REAL array, dimension (N**2)",
       "        Contains the square eigenblocks from previous levels, the",
       "        starting positions for blocks are given by QPTR."],
     "QPTR"=>
      ["[in]",
       "         QPTR is INTEGER array, dimension (N+2)",
       "        Contains a list of pointers which indicate where in Q an",
       "        eigenblock is stored.  SQRT( QPTR(i+1) - QPTR(i) ) indicates",
       "        the size of the block."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (N)",
       "        On output this vector contains the updating vector (the last",
       "        row of the first sub-eigenvector matrix and the first row of",
       "        the second sub-eigenvector matrix)."],
     "ZTEMP"=>["[out]", "         ZTEMP is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slasrt"=>
  {"summary"=>
    ["Sort the numbers in D in increasing order (if ID = 'I') or",
     "in decreasing order (if ID = 'D' ).",
     "Use Quick Sort, reverting to Insertion sort on arrays of",
     "size <= 20. Dimension of STACK limits N to about 2**32."],
   "param"=>
    {"ID"=>
      ["[in]",
       "         ID is CHARACTER*1",
       "         = 'I': sort D in increasing order;",
       "         = 'D': sort D in decreasing order."],
     "N"=>
      ["[in]", "         N is INTEGER", "         The length of the array D."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the array to be sorted.",
       "         On exit, D has been sorted into increasing order",
       "         (D(1) <= ... <= D(N) ) or into decreasing order",
       "         (D(1) >= ... >= D(N) ), depending on ID."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slascl"=>
  {"summary"=>
    ["SLASCL multiplies the M by N real matrix A by the real scalar",
     "CTO/CFROM.  This is done without over/underflow as long as the final",
     "result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that",
     "A may be full, upper triangular, lower triangular, upper Hessenberg,",
     "or banded."],
   "param"=>
    {"TYPE"=>
      ["[in]",
       "         TYPE is CHARACTER*1",
       "         TYPE indices the storage type of the input matrix.",
       "         = 'G':  A is a full matrix.",
       "         = 'L':  A is a lower triangular matrix.",
       "         = 'U':  A is an upper triangular matrix.",
       "         = 'H':  A is an upper Hessenberg matrix.",
       "         = 'B':  A is a symmetric band matrix with lower bandwidth KL",
       "                 and upper bandwidth KU and with the only the lower",
       "                 half stored.",
       "         = 'Q':  A is a symmetric band matrix with lower bandwidth KL",
       "                 and upper bandwidth KU and with the only the upper",
       "                 half stored.",
       "         = 'Z':  A is a band matrix with lower bandwidth KL and upper",
       "                 bandwidth KU. See SGBTRF for storage details."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The lower bandwidth of A.  Referenced only if TYPE = 'B',",
       "         'Q' or 'Z'."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The upper bandwidth of A.  Referenced only if TYPE = 'B',",
       "         'Q' or 'Z'."],
     "CFROM"=>["[in]", "         CFROM is REAL"],
     "CTO"=>
      ["[in]",
       "         CTO is REAL",
       "         The matrix A is multiplied by CTO/CFROM. A(I,J) is computed",
       "         without over/underflow if the final result CTO*A(I,J)/CFROM",
       "         can be represented without over/underflow.  CFROM must be",
       "         nonzero."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         The matrix to be multiplied by CTO/CFROM.  See TYPE for the",
       "         storage type."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If TYPE = 'G', 'L', 'U', 'H', LDA >= max(1,M);",
       "            TYPE = 'B', LDA >= KL+1;",
       "            TYPE = 'Q', LDA >= KU+1;",
       "            TYPE = 'Z', LDA >= 2*KL+KU+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         0  - successful exit",
       "         <0 - if INFO = -i, the i-th argument had an illegal value."]}},
 "sggrqf"=>
  {"summary"=>
    ["SGGRQF computes a generalized RQ factorization of an M-by-N matrix A",
     "and a P-by-N matrix B:",
     "            A = R*Q,        B = Z*T*Q,",
     "where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal",
     "matrix, and R and T assume one of the forms:",
     "if M <= N,  R = ( 0  R12 ) M,   or if M > N,  R = ( R11 ) M-N,",
     "                 N-M  M                           ( R21 ) N",
     "                                                     N",
     "where R12 or R21 is upper triangular, and",
     "if P >= N,  T = ( T11 ) N  ,   or if P < N,  T = ( T11  T12 ) P,",
     "                (  0  ) P-N                         P   N-P",
     "                   N",
     "where T11 is upper triangular.",
     "In particular, if B is square and nonsingular, the GRQ factorization",
     "of A and B implicitly gives the RQ factorization of A*inv(B):",
     "             A*inv(B) = (R*inv(T))*Z**T",
     "where inv(B) denotes the inverse of the matrix B, and Z**T denotes the",
     "transpose of the matrix Z."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, if M <= N, the upper triangle of the subarray",
       "         A(1:M,N-M+1:N) contains the M-by-M upper triangular matrix R;",
       "         if M > N, the elements on and above the (M-N)-th subdiagonal",
       "         contain the M-by-N upper trapezoidal matrix R; the remaining",
       "         elements, with the array TAUA, represent the orthogonal",
       "         matrix Q as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "TAUA"=>
      ["[out]",
       "         TAUA is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Q (see Further Details)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(P,N)-by-N upper trapezoidal matrix T (T is",
       "         upper triangular if P >= N); the elements below the diagonal,",
       "         with the array TAUB, represent the orthogonal matrix Z as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TAUB"=>
      ["[out]",
       "         TAUB is REAL array, dimension (min(P,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Z (see Further Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N,M,P).",
       "         For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),",
       "         where NB1 is the optimal blocksize for the RQ factorization",
       "         of an M-by-N matrix, NB2 is the optimal blocksize for the",
       "         QR factorization of a P-by-N matrix, and NB3 is the optimal",
       "         blocksize for a call of SORMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INF0= -i, the i-th argument had an illegal value."]}},
 "cgbsv"=>
  {"summary"=>
    ["CGBSV computes the solution to a complex system of linear equations",
     "A * X = B, where A is a band matrix of order N with KL subdiagonals",
     "and KU superdiagonals, and X and B are N-by-NRHS matrices.",
     "The LU decomposition with partial pivoting and row interchanges is",
     "used to factor A as A = L * U, where L is a product of permutation",
     "and unit lower triangular matrices with KL subdiagonals, and U is",
     "upper triangular with KL+KU superdiagonals.  The factored form of A",
     "is then used to solve the system of equations A * X = B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(KL+KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+KL)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices that define the permutation matrix P;",
       "         row i of the matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero.  The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and the solution has not been computed."]}},
 "chetrs_rook"=>
  {"summary"=>
    ["CHETRS_ROOK solves a system of linear equations A*X = B with a complex",
     "Hermitian matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by CHETRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CHETRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF_ROOK."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dposvx"=>
  {"summary"=>
    ["DPOSVX uses the Cholesky factorization A = U**T*U or A = L*L**T to",
     "compute the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite matrix and X and B",
     "are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "dgemlq"=>
  {"summary"=>
    ["    DGEMLQ overwrites the general real M-by-N matrix C with",
     "                   SIDE = 'L'     SIDE = 'R'",
     "   TRANS = 'N':      Q * C          C * Q",
     "   TRANS = 'T':      Q**T * C       C * Q**T",
     "   where Q is a real orthogonal matrix defined as the product",
     "   of blocked elementary reflectors computed by short wide LQ",
     "   factorization (DGELQ)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         Part of the data structure to represent Q as returned by DGELQ."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (MAX(5,TSIZE)).",
       "         Part of the data structure to represent Q as returned by DGELQ."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         The dimension of the array T. TSIZE >= 5."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "        (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed. The routine",
       "         only calculates the size of the WORK array, returns this",
       "         value as WORK(1), and no error message related to WORK ",
       "         is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgerfsx"=>
  {"summary"=>
    ["   DGERFSX improves the computed solution to a system of linear",
     "   equations and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED, R",
     "   and C below. In this case, the solution and error bounds returned",
     "   are for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "              diag(R).",
       "      = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "              by diag(C).",
       "      = 'B':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(R) * A * diag(C).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    The original N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The factors L and U from the factorization A = P*L*U",
       "    as computed by DGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from DGETRF; for 1<=i<=N, row i of the",
       "    matrix was interchanged with row IPIV(i)."],
     "R"=>
      ["[in]",
       "         R is DOUBLE PRECISION array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'R' or 'B', A is",
       "    multiplied on the left by diag(R); if EQUED = 'N' or 'C', R",
       "    is not accessed.",
       "    If R is accessed, each element of R should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A.  If EQUED = 'C' or 'B', A is",
       "    multiplied on the right by diag(C); if EQUED = 'N' or 'R', C",
       "    is not accessed.",
       "    If C is accessed, each element of C should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by DGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is DOUBLE PRECISION array, dimension (NPARAMS)",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0D+0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "dsytri_3x"=>
  {"summary"=>
    ["DSYTRI_3X computes the inverse of a real symmetric indefinite",
     "matrix A using the factorization computed by DSYTRF_RK or DSYTRF_BK:",
     "    A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by DSYTRF_RK and DSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the symmetric inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF_RK or DSYTRF_BK."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (N+NB+1,NB+3)."],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "clarfb"=>
  {"summary"=>
    ["CLARFB applies a complex block reflector H or its transpose H**H to a",
     "complex M-by-N matrix C, from either the left or the right."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H**H from the Left",
       "         = 'R': apply H or H**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'C': apply H**H (Conjugate transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columnwise",
       "         = 'R': Rowwise"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T (= the number of elementary",
       "         reflectors whose product defines the block reflector)."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension",
       "                               (LDV,K) if STOREV = 'C'",
       "                               (LDV,M) if STOREV = 'R' and SIDE = 'L'",
       "                               (LDV,N) if STOREV = 'R' and SIDE = 'R'",
       "         The matrix V. See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);",
       "         if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);",
       "         if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension (LDT,K)",
       "         The triangular K-by-K matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by H*C or H**H*C or C*H or C*H**H."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (LDWORK,K)"],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= max(1,N);",
       "         if SIDE = 'R', LDWORK >= max(1,M)."]}},
 "clacrt"=>
  {"summary"=>
    ["CLACRT performs the operation",
     "   (  c  s )( x )  ==> ( x )",
     "   ( -s  c )( y )      ( y )",
     "where c and s are complex and the vectors x and y are complex."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements in the vectors CX and CY."],
     "CX"=>
      ["[in,out]",
       "         CX is COMPLEX array, dimension (N)",
       "         On input, the vector x.",
       "         On output, CX is overwritten with c*x + s*y."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of CX.  INCX <> 0."],
     "CY"=>
      ["[in,out]",
       "         CY is COMPLEX array, dimension (N)",
       "         On input, the vector y.",
       "         On output, CY is overwritten with -s*x + c*y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between successive values of CY.  INCY <> 0."],
     "C"=>["[in]", "         C is COMPLEX"],
     "S"=>
      ["[in]",
       "         S is COMPLEX",
       "         C and S define the matrix",
       "            [  C   S  ].",
       "            [ -S   C  ]"]}},
 "dpftri"=>
  {"summary"=>
    ["DPFTRI computes the inverse of a (real) symmetric positive definite",
     "matrix A using the Cholesky factorization A = U**T*U or A = L*L**T",
     "computed by DPFTRF."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'T':  The Transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension ( N*(N+1)/2 )",
       "         On entry, the symmetric matrix A in RFP format. RFP format is",
       "         described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'",
       "         then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'T' then RFP is",
       "         the transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the nt elements of",
       "         upper packed A. If UPLO = 'L' the RFP A contains the elements",
       "         of lower packed A. The LDA of RFP A is (N+1)/2 when TRANSR =",
       "         'T'. When TRANSR is 'N' the LDA is N+1 when N is even and N",
       "         is odd. See the Note below for more details.",
       "         On exit, the symmetric inverse of the original matrix, in the",
       "         same storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "slaqr2"=>
  {"summary"=>
    ["   SLAQR2 is identical to SLAQR3 except that it avoids",
     "   recursion by calling SLAHQR instead of SLAQR4.",
     "   Aggressive early deflation:",
     "   This subroutine accepts as input an upper Hessenberg matrix",
     "   H and performs an orthogonal similarity transformation",
     "   designed to detect and deflate fully converged eigenvalues from",
     "   a trailing principal submatrix.  On output H has been over-",
     "   written by a new Hessenberg matrix that is a perturbation of",
     "   an orthogonal similarity transformation of H.  It is to be",
     "   hoped that the final version of H has many zero subdiagonal",
     "   entries."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         If .TRUE., then the Hessenberg matrix H is fully updated",
       "         so that the quasi-triangular Schur factor may be",
       "         computed (in cooperation with the calling subroutine).",
       "         If .FALSE., then only enough of H is updated to preserve",
       "         the eigenvalues."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         If .TRUE., then the orthogonal matrix Z is updated so",
       "         so that the orthogonal Schur factor may be computed",
       "         (in cooperation with the calling subroutine).",
       "         If .FALSE., then Z is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H and (if WANTZ is .TRUE.) the",
       "         order of the orthogonal matrix Z."],
     "KTOP"=>
      ["[in]",
       "         KTOP is INTEGER",
       "         It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.",
       "         KBOT and KTOP together determine an isolated block",
       "         along the diagonal of the Hessenberg matrix."],
     "KBOT"=>
      ["[in]",
       "         KBOT is INTEGER",
       "         It is assumed without a check that either",
       "         KBOT = N or H(KBOT+1,KBOT)=0.  KBOT and KTOP together",
       "         determine an isolated block along the diagonal of the",
       "         Hessenberg matrix."],
     "NW"=>
      ["[in]",
       "         NW is INTEGER",
       "         Deflation window size.  1 .LE. NW .LE. (KBOT-KTOP+1)."],
     "H"=>
      ["[in,out]",
       "         H is REAL array, dimension (LDH,N)",
       "         On input the initial N-by-N section of H stores the",
       "         Hessenberg matrix undergoing aggressive early deflation.",
       "         On output H has been transformed by an orthogonal",
       "         similarity transformation, perturbed, and the returned",
       "         to Hessenberg form that (it is to be hoped) has some",
       "         zero subdiagonal entries."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "         Leading dimension of H just as declared in the calling",
       "         subroutine.  N .LE. LDH"],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ,N)",
       "         IF WANTZ is .TRUE., then on output, the orthogonal",
       "         similarity transformation mentioned above has been",
       "         accumulated into Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "         If WANTZ is .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer",
       "         The leading dimension of Z just as declared in the",
       "         calling subroutine.  1 .LE. LDZ."],
     "NS"=>
      ["[out]",
       "         NS is integer",
       "         The number of unconverged (ie approximate) eigenvalues",
       "         returned in SR and SI that may be used as shifts by the",
       "         calling subroutine."],
     "ND"=>
      ["[out]",
       "         ND is integer",
       "         The number of converged eigenvalues uncovered by this",
       "         subroutine."],
     "SR"=>["[out]", "         SR is REAL array, dimension KBOT"],
     "SI"=>
      ["[out]",
       "         SI is REAL array, dimension KBOT",
       "         On output, the real and imaginary parts of approximate",
       "         eigenvalues that may be used for shifts are stored in",
       "         SR(KBOT-ND-NS+1) through SR(KBOT-ND) and",
       "         SI(KBOT-ND-NS+1) through SI(KBOT-ND), respectively.",
       "         The real and imaginary parts of converged eigenvalues",
       "         are stored in SR(KBOT-ND+1) through SR(KBOT) and",
       "         SI(KBOT-ND+1) through SI(KBOT), respectively."],
     "V"=>
      ["[out]",
       "         V is REAL array, dimension (LDV,NW)",
       "         An NW-by-NW work array."],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "         The leading dimension of V just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "         The number of columns of T.  NH.GE.NW."],
     "T"=>["[out]", "         T is REAL array, dimension (LDT,NW)"],
     "LDT"=>
      ["[in]",
       "         LDT is integer",
       "         The leading dimension of T just as declared in the",
       "         calling subroutine.  NW .LE. LDT"],
     "NV"=>
      ["[in]",
       "         NV is integer",
       "         The number of rows of work array WV available for",
       "         workspace.  NV.GE.NW."],
     "WV"=>["[out]", "         WV is REAL array, dimension (LDWV,NW)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer",
       "         The leading dimension of W just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension LWORK.",
       "         On exit, WORK(1) is set to an estimate of the optimal value",
       "         of LWORK for the given values of N, NW, KTOP and KBOT."],
     "LWORK"=>
      ["[in]",
       "         LWORK is integer",
       "         The dimension of the work array WORK.  LWORK = 2*NW",
       "         suffices, but greater efficiency may result from larger",
       "         values of LWORK.",
       "         If LWORK = -1, then a workspace query is assumed; SLAQR2",
       "         only estimates the optimal workspace size for the given",
       "         values of N, NW, KTOP and KBOT.  The estimate is returned",
       "         in WORK(1).  No error message related to LWORK is issued",
       "         by XERBLA.  Neither H nor Z are accessed."]}},
 "zgbrfs"=>
  {"summary"=>
    ["ZGBRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is banded, and provides",
     "error bounds and backward error estimates for the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The original band matrix A, stored in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX*16 array, dimension (LDAFB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by ZGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "         The leading dimension of the array AFB.  LDAFB >= 2*KL*KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from ZGBTRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by ZGBTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlasda"=>
  {"summary"=>
    ["Using a divide and conquer approach, DLASDA computes the singular",
     "value decomposition (SVD) of a real upper bidiagonal N-by-M matrix",
     "B with diagonal D and offdiagonal E, where M = N + SQRE. The",
     "algorithm computes the singular values in the SVD B = U * S * VT.",
     "The orthogonal matrices U and VT are optionally computed in",
     "compact form.",
     "A related subroutine, DLASD0, computes the singular values and",
     "the singular vectors in explicit form."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether singular vectors are to be computed",
       "        in compact form, as follows",
       "        = 0: Compute singular values only.",
       "        = 1: Compute singular vectors of upper bidiagonal",
       "             matrix in compact form."],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        The maximum size of the subproblems at the bottom of the",
       "        computation tree."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The row dimension of the upper bidiagonal matrix. This is",
       "        also the dimension of the main diagonal array D."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        Specifies the column dimension of the bidiagonal matrix.",
       "        = 0: The bidiagonal matrix has column dimension M = N;",
       "        = 1: The bidiagonal matrix has column dimension M = N + 1."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension ( N )",
       "        On entry D contains the main diagonal of the bidiagonal",
       "        matrix. On exit D, if INFO = 0, contains its singular values."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension ( M-1 )",
       "        Contains the subdiagonal entries of the bidiagonal matrix.",
       "        On exit, E has been destroyed."],
     "U"=>
      ["[out]",
       "         U is DOUBLE PRECISION array,",
       "        dimension ( LDU, SMLSIZ ) if ICOMPQ = 1, and not referenced",
       "        if ICOMPQ = 0. If ICOMPQ = 1, on exit, U contains the left",
       "        singular vector matrices of all subproblems at the bottom",
       "        level."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER, LDU = > N.",
       "        The leading dimension of arrays U, VT, DIFL, DIFR, POLES,",
       "        GIVNUM, and Z."],
     "VT"=>
      ["[out]",
       "         VT is DOUBLE PRECISION array,",
       "        dimension ( LDU, SMLSIZ+1 ) if ICOMPQ = 1, and not referenced",
       "        if ICOMPQ = 0. If ICOMPQ = 1, on exit, VT**T contains the right",
       "        singular vector matrices of all subproblems at the bottom",
       "        level."],
     "K"=>
      ["[out]",
       "         K is INTEGER array,",
       "        dimension ( N ) if ICOMPQ = 1 and dimension 1 if ICOMPQ = 0.",
       "        If ICOMPQ = 1, on exit, K(I) is the dimension of the I-th",
       "        secular equation on the computation tree."],
     "DIFL"=>
      ["[out]",
       "         DIFL is DOUBLE PRECISION array, dimension ( LDU, NLVL ),",
       "        where NLVL = floor(log_2 (N/SMLSIZ)))."],
     "DIFR"=>
      ["[out]",
       "         DIFR is DOUBLE PRECISION array,",
       "                 dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1 and",
       "                 dimension ( N ) if ICOMPQ = 0.",
       "        If ICOMPQ = 1, on exit, DIFL(1:N, I) and DIFR(1:N, 2 * I - 1)",
       "        record distances between singular values on the I-th",
       "        level and singular values on the (I -1)-th level, and",
       "        DIFR(1:N, 2 * I ) contains the normalizing factors for",
       "        the right singular vector matrix. See DLASD8 for details."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array,",
       "                 dimension ( LDU, NLVL ) if ICOMPQ = 1 and",
       "                 dimension ( N ) if ICOMPQ = 0.",
       "        The first K elements of Z(1, I) contain the components of",
       "        the deflation-adjusted updating row vector for subproblems",
       "        on the I-th level."],
     "POLES"=>
      ["[out]",
       "         POLES is DOUBLE PRECISION array,",
       "        dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1, and not referenced",
       "        if ICOMPQ = 0. If ICOMPQ = 1, on exit, POLES(1, 2*I - 1) and",
       "        POLES(1, 2*I) contain  the new and old singular values",
       "        involved in the secular equations on the I-th level."],
     "GIVPTR"=>
      ["[out]",
       "         GIVPTR is INTEGER array,",
       "        dimension ( N ) if ICOMPQ = 1, and not referenced if",
       "        ICOMPQ = 0. If ICOMPQ = 1, on exit, GIVPTR( I ) records",
       "        the number of Givens rotations performed on the I-th",
       "        problem on the computation tree."],
     "GIVCOL"=>
      ["[out]",
       "         GIVCOL is INTEGER array,",
       "        dimension ( LDGCOL, 2 * NLVL ) if ICOMPQ = 1, and not",
       "        referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I,",
       "        GIVCOL(1, 2 *I - 1) and GIVCOL(1, 2 *I) record the locations",
       "        of Givens rotations performed on the I-th level on the",
       "        computation tree."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER, LDGCOL = > N.",
       "        The leading dimension of arrays GIVCOL and PERM."],
     "PERM"=>
      ["[out]",
       "         PERM is INTEGER array,",
       "        dimension ( LDGCOL, NLVL ) if ICOMPQ = 1, and not referenced",
       "        if ICOMPQ = 0. If ICOMPQ = 1, on exit, PERM(1, I) records",
       "        permutations done on the I-th level of the computation tree."],
     "GIVNUM"=>
      ["[out]",
       "         GIVNUM is DOUBLE PRECISION array,",
       "        dimension ( LDU,  2 * NLVL ) if ICOMPQ = 1, and not",
       "        referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I,",
       "        GIVNUM(1, 2 *I - 1) and GIVNUM(1, 2 *I) record the C- and S-",
       "        values of Givens rotations performed on the I-th level on",
       "        the computation tree."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION array,",
       "        dimension ( N ) if ICOMPQ = 1, and dimension 1 if ICOMPQ = 0.",
       "        If ICOMPQ = 1 and the I-th subproblem is not square, on exit,",
       "        C( I ) contains the C-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension ( N ) if",
       "        ICOMPQ = 1, and dimension 1 if ICOMPQ = 0. If ICOMPQ = 1",
       "        and the I-th subproblem is not square, on exit, S( I )",
       "        contains the S-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension",
       "        (6 * N + (SMLSIZ + 1)*(SMLSIZ + 1))."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array.",
       "        Dimension must be at least (7 * N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, a singular value did not converge"]}},
 "dtpqrt2"=>
  {"summary"=>
    ["DTPQRT2 computes a QR factorization of a real \"triangular-pentagonal\"",
     "matrix C, which is composed of a triangular block A and pentagonal block B,",
     "using the compact WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of",
       "         the triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the upper trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the upper triangular N-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first M-L rows",
       "         are rectangular, and the last L rows are upper trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor T of the block reflector.",
       "         See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zlarnv"=>
  {"summary"=>
    ["ZLARNV returns a vector of n random complex numbers from a uniform or",
     "normal distribution."],
   "param"=>
    {"IDIST"=>
      ["[in]",
       "         IDIST is INTEGER",
       "         Specifies the distribution of the random numbers:",
       "         = 1:  real and imaginary parts each uniform (0,1)",
       "         = 2:  real and imaginary parts each uniform (-1,1)",
       "         = 3:  real and imaginary parts each normal (0,1)",
       "         = 4:  uniformly distributed on the disc abs(z) < 1",
       "         = 5:  uniformly distributed on the circle abs(z) = 1"],
     "ISEED"=>
      ["[in,out]",
       "         ISEED is INTEGER array, dimension (4)",
       "         On entry, the seed of the random number generator; the array",
       "         elements must be between 0 and 4095, and ISEED(4) must be",
       "         odd.",
       "         On exit, the seed is updated."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of random numbers to be generated."],
     "X"=>
      ["[out]",
       "         X is COMPLEX*16 array, dimension (N)",
       "         The generated random numbers."]}},
 "dla_gbrpvgrw"=>
  {"summary"=>
    ["DLA_GBRPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A.  NCOLS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "    On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is DOUBLE PRECISION array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by DGBTRF.  U is stored as an upper triangular",
       "    band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1,",
       "    and the multipliers used during the factorization are stored",
       "    in rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1."]}},
 "zgesvxx"=>
  {"summary"=>
    ["   ZGESVXX uses the LU factorization to compute the solution to a",
     "   complex*16 system of linear equations  A * X = B,  where A is an",
     "   N-by-N matrix and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. ZGESVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   ZGESVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   ZGESVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what ZGESVXX would itself produce."],
   "param"=>nil},
 "sgeqr2"=>
  {"summary"=>
    ["SGEQR2 computes a QR factorization of a real m by n matrix A:",
     "A = Q * R."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(m,n) by n upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n); the elements below the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "claqsy"=>
  {"summary"=>
    ["CLAQSY equilibrates a symmetric matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if EQUED = 'Y', the equilibrated matrix:",
       "         diag(S) * A * diag(S)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is REAL",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "cgtcon"=>
  {"summary"=>
    ["CGTCON estimates the reciprocal of the condition number of a complex",
     "tridiagonal matrix A using the LU factorization as computed by",
     "CGTTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A as computed by CGTTRF."],
     "D"=>
      ["[in]",
       "         D is COMPLEX array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX array, dimension (N-1)",
       "         The (n-1) elements of the first superdiagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is COMPLEX array, dimension (N-2)",
       "         The (n-2) elements of the second superdiagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ssygvd"=>
  {"summary"=>
    ["SSYGVD computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be symmetric and B is also positive definite.",
     "If eigenvectors are desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, the symmetric matrix B.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of B contains the",
       "         upper triangular part of the matrix B.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of B contains",
       "         the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LWORK >= 2*N+1.",
       "         If JOBZ = 'V' and N > 1, LWORK >= 1 + 6*N + 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK >= 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK >= 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  SPOTRF or SSYEVD returned an error code:",
       "            <= N:  if INFO = i and JOBZ = 'N', then the algorithm",
       "                   failed to converge; i off-diagonal elements of an",
       "                   intermediate tridiagonal form did not converge to",
       "                   zero;",
       "                   if INFO = i and JOBZ = 'V', then the algorithm",
       "                   failed to compute an eigenvalue while working on",
       "                   the submatrix lying in rows and columns INFO/(N+1)",
       "                   through mod(INFO,N+1);",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "slaisnan"=>
  {"summary"=>
    ["This routine is not for general use.  It exists solely to avoid",
     "over-optimization in SISNAN.",
     "SLAISNAN checks for NaNs by comparing its two arguments for",
     "inequality.  NaN is the only floating-point value where NaN != NaN",
     "returns .TRUE.  To check for NaNs, pass the same variable as both",
     "arguments.",
     "A compiler must assume that the two arguments are",
     "not the same variable, and the test will not be optimized away.",
     "Interprocedural or whole-program optimization may delete this",
     "test.  The ISNAN functions will be replaced by the correct",
     "Fortran 03 intrinsic once the intrinsic is widely available."],
   "param"=>
    {"SIN1"=>["[in]", "         SIN1 is REAL"],
     "SIN2"=>
      ["[in]",
       "         SIN2 is REAL",
       "         Two numbers to compare for inequality."]}},
 "clals0"=>
  {"summary"=>
    ["CLALS0 applies back the multiplying factors of either the left or the",
     "right singular vector matrix of a diagonal matrix appended by a row",
     "to the right hand side matrix B in solving the least squares problem",
     "using the divide-and-conquer SVD approach.",
     "For the left singular vector matrix, three types of orthogonal",
     "matrices are involved:",
     "(1L) Givens rotations: the number of such rotations is GIVPTR; the",
     "     pairs of columns/rows they were applied to are stored in GIVCOL;",
     "     and the C- and S-values of these rotations are stored in GIVNUM.",
     "(2L) Permutation. The (NL+1)-st row of B is to be moved to the first",
     "     row, and for J=2:N, PERM(J)-th row of B is to be moved to the",
     "     J-th row.",
     "(3L) The left singular vector matrix of the remaining matrix.",
     "For the right singular vector matrix, four types of orthogonal",
     "matrices are involved:",
     "(1R) The right singular vector matrix of the remaining matrix.",
     "(2R) If SQRE = 1, one extra Givens rotation to generate the right",
     "     null space.",
     "(3R) The inverse transformation of (2L).",
     "(4R) The inverse transformation of (1L)."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether singular vectors are to be computed in",
       "        factored form:",
       "        = 0: Left singular vector matrix.",
       "        = 1: Right singular vector matrix."],
     "NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block. NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block. NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has row dimension N = NL + NR + 1,",
       "        and column dimension M = N + SQRE."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B and BX. NRHS must be at least 1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension ( LDB, NRHS )",
       "        On input, B contains the right hand sides of the least",
       "        squares problem in rows 1 through M. On output, B contains",
       "        the solution X in rows 1 through N."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B. LDB must be at least",
       "        max(1,MAX( M, N ) )."],
     "BX"=>["[out]", "         BX is COMPLEX array, dimension ( LDBX, NRHS )"],
     "LDBX"=>
      ["[in]",
       "         LDBX is INTEGER",
       "        The leading dimension of BX."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension ( N )",
       "        The permutations (from deflation and sorting) applied",
       "        to the two blocks."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER",
       "        The number of Givens rotations which took place in this",
       "        subproblem."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )",
       "        Each pair of numbers indicates a pair of rows/columns",
       "        involved in a Givens rotation."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER",
       "        The leading dimension of GIVCOL, must be at least N."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is REAL array, dimension ( LDGNUM, 2 )",
       "        Each number indicates the C or S value used in the",
       "        corresponding Givens rotation."],
     "LDGNUM"=>
      ["[in]",
       "         LDGNUM is INTEGER",
       "        The leading dimension of arrays DIFR, POLES and",
       "        GIVNUM, must be at least K."],
     "POLES"=>
      ["[in]",
       "         POLES is REAL array, dimension ( LDGNUM, 2 )",
       "        On entry, POLES(1:K, 1) contains the new singular",
       "        values obtained from solving the secular equation, and",
       "        POLES(1:K, 2) is an array containing the poles in the secular",
       "        equation."],
     "DIFL"=>
      ["[in]",
       "         DIFL is REAL array, dimension ( K ).",
       "        On entry, DIFL(I) is the distance between I-th updated",
       "        (undeflated) singular value and the I-th (undeflated) old",
       "        singular value."],
     "DIFR"=>
      ["[in]",
       "         DIFR is REAL array, dimension ( LDGNUM, 2 ).",
       "        On entry, DIFR(I, 1) contains the distances between I-th",
       "        updated (undeflated) singular value and the I+1-th",
       "        (undeflated) old singular value. And DIFR(I, 2) is the",
       "        normalizing factor for the I-th right singular vector."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension ( K )",
       "        Contain the components of the deflation-adjusted updating row",
       "        vector."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "        Contains the dimension of the non-deflated matrix,",
       "        This is the order of the related secular equation. 1 <= K <=N."],
     "C"=>
      ["[in]",
       "         C is REAL",
       "        C contains garbage if SQRE =0 and the C-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "S"=>
      ["[in]",
       "         S is REAL",
       "        S contains garbage if SQRE =0 and the S-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension",
       "        ( K*(1+NRHS) + 2*NRHS )"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "cgeqrt2"=>
  {"summary"=>
    ["CGEQRT2 computes a QR factorization of a complex M-by-N matrix A,",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the complex M-by-N matrix A.  On exit, the elements on and",
       "         above the diagonal contain the N-by-N upper triangular matrix R; the",
       "         elements below the diagonal are the columns of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dormrq"=>
  {"summary"=>
    ["DORMRQ overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by DGERQF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGERQF in the last k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGERQF."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clarnv"=>
  {"summary"=>
    ["CLARNV returns a vector of n random complex numbers from a uniform or",
     "normal distribution."],
   "param"=>
    {"IDIST"=>
      ["[in]",
       "         IDIST is INTEGER",
       "         Specifies the distribution of the random numbers:",
       "         = 1:  real and imaginary parts each uniform (0,1)",
       "         = 2:  real and imaginary parts each uniform (-1,1)",
       "         = 3:  real and imaginary parts each normal (0,1)",
       "         = 4:  uniformly distributed on the disc abs(z) < 1",
       "         = 5:  uniformly distributed on the circle abs(z) = 1"],
     "ISEED"=>
      ["[in,out]",
       "         ISEED is INTEGER array, dimension (4)",
       "         On entry, the seed of the random number generator; the array",
       "         elements must be between 0 and 4095, and ISEED(4) must be",
       "         odd.",
       "         On exit, the seed is updated."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of random numbers to be generated."],
     "X"=>
      ["[out]",
       "         X is COMPLEX array, dimension (N)",
       "         The generated random numbers."]}},
 "zgehd2"=>
  {"summary"=>
    ["ZGEHD2 reduces a complex general matrix A to upper Hessenberg form H",
     "by a unitary similarity transformation:  Q**H * A * Q = H ."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that A is already upper triangular in rows",
       "         and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "         set by a previous call to ZGEBAL; otherwise they should be",
       "         set to 1 and N respectively. See Further Details.",
       "         1 <= ILO <= IHI <= max(1,N)."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the n by n general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         elements below the first subdiagonal, with the array TAU,",
       "         represent the unitary matrix Q as a product of elementary",
       "         reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dlaqr3"=>
  {"summary"=>
    ["   Aggressive early deflation:",
     "   DLAQR3 accepts as input an upper Hessenberg matrix",
     "   H and performs an orthogonal similarity transformation",
     "   designed to detect and deflate fully converged eigenvalues from",
     "   a trailing principal submatrix.  On output H has been over-",
     "   written by a new Hessenberg matrix that is a perturbation of",
     "   an orthogonal similarity transformation of H.  It is to be",
     "   hoped that the final version of H has many zero subdiagonal",
     "   entries."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         If .TRUE., then the Hessenberg matrix H is fully updated",
       "         so that the quasi-triangular Schur factor may be",
       "         computed (in cooperation with the calling subroutine).",
       "         If .FALSE., then only enough of H is updated to preserve",
       "         the eigenvalues."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         If .TRUE., then the orthogonal matrix Z is updated so",
       "         so that the orthogonal Schur factor may be computed",
       "         (in cooperation with the calling subroutine).",
       "         If .FALSE., then Z is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H and (if WANTZ is .TRUE.) the",
       "         order of the orthogonal matrix Z."],
     "KTOP"=>
      ["[in]",
       "         KTOP is INTEGER",
       "         It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.",
       "         KBOT and KTOP together determine an isolated block",
       "         along the diagonal of the Hessenberg matrix."],
     "KBOT"=>
      ["[in]",
       "         KBOT is INTEGER",
       "         It is assumed without a check that either",
       "         KBOT = N or H(KBOT+1,KBOT)=0.  KBOT and KTOP together",
       "         determine an isolated block along the diagonal of the",
       "         Hessenberg matrix."],
     "NW"=>
      ["[in]",
       "         NW is INTEGER",
       "         Deflation window size.  1 .LE. NW .LE. (KBOT-KTOP+1)."],
     "H"=>
      ["[in,out]",
       "         H is DOUBLE PRECISION array, dimension (LDH,N)",
       "         On input the initial N-by-N section of H stores the",
       "         Hessenberg matrix undergoing aggressive early deflation.",
       "         On output H has been transformed by an orthogonal",
       "         similarity transformation, perturbed, and the returned",
       "         to Hessenberg form that (it is to be hoped) has some",
       "         zero subdiagonal entries."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "         Leading dimension of H just as declared in the calling",
       "         subroutine.  N .LE. LDH"],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ,N)",
       "         IF WANTZ is .TRUE., then on output, the orthogonal",
       "         similarity transformation mentioned above has been",
       "         accumulated into Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "         If WANTZ is .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer",
       "         The leading dimension of Z just as declared in the",
       "         calling subroutine.  1 .LE. LDZ."],
     "NS"=>
      ["[out]",
       "         NS is integer",
       "         The number of unconverged (ie approximate) eigenvalues",
       "         returned in SR and SI that may be used as shifts by the",
       "         calling subroutine."],
     "ND"=>
      ["[out]",
       "         ND is integer",
       "         The number of converged eigenvalues uncovered by this",
       "         subroutine."],
     "SR"=>
      ["[out]", "         SR is DOUBLE PRECISION array, dimension (KBOT)"],
     "SI"=>
      ["[out]",
       "         SI is DOUBLE PRECISION array, dimension (KBOT)",
       "         On output, the real and imaginary parts of approximate",
       "         eigenvalues that may be used for shifts are stored in",
       "         SR(KBOT-ND-NS+1) through SR(KBOT-ND) and",
       "         SI(KBOT-ND-NS+1) through SI(KBOT-ND), respectively.",
       "         The real and imaginary parts of converged eigenvalues",
       "         are stored in SR(KBOT-ND+1) through SR(KBOT) and",
       "         SI(KBOT-ND+1) through SI(KBOT), respectively."],
     "V"=>
      ["[out]",
       "         V is DOUBLE PRECISION array, dimension (LDV,NW)",
       "         An NW-by-NW work array."],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "         The leading dimension of V just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "         The number of columns of T.  NH.GE.NW."],
     "T"=>
      ["[out]", "         T is DOUBLE PRECISION array, dimension (LDT,NW)"],
     "LDT"=>
      ["[in]",
       "         LDT is integer",
       "         The leading dimension of T just as declared in the",
       "         calling subroutine.  NW .LE. LDT"],
     "NV"=>
      ["[in]",
       "         NV is integer",
       "         The number of rows of work array WV available for",
       "         workspace.  NV.GE.NW."],
     "WV"=>
      ["[out]", "         WV is DOUBLE PRECISION array, dimension (LDWV,NW)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer",
       "         The leading dimension of W just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LWORK)",
       "         On exit, WORK(1) is set to an estimate of the optimal value",
       "         of LWORK for the given values of N, NW, KTOP and KBOT."],
     "LWORK"=>
      ["[in]",
       "         LWORK is integer",
       "         The dimension of the work array WORK.  LWORK = 2*NW",
       "         suffices, but greater efficiency may result from larger",
       "         values of LWORK.",
       "         If LWORK = -1, then a workspace query is assumed; DLAQR3",
       "         only estimates the optimal workspace size for the given",
       "         values of N, NW, KTOP and KBOT.  The estimate is returned",
       "         in WORK(1).  No error message related to LWORK is issued",
       "         by XERBLA.  Neither H nor Z are accessed."]}},
 "zpbtrf"=>
  {"summary"=>
    ["ZPBTRF computes the Cholesky factorization of a complex Hermitian",
     "positive definite band matrix A.",
     "The factorization has the form",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H*U or A = L*L**H of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "slaexc"=>
  {"summary"=>
    ["SLAEXC swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in",
     "an upper quasi-triangular matrix T by an orthogonal similarity",
     "transformation.",
     "T must be in Schur canonical form, that is, block upper triangular",
     "with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block",
     "has its diagonal elemnts equal and its off-diagonal elements of",
     "opposite sign."],
   "param"=>
    {"WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         = .TRUE. : accumulate the transformation in the matrix Q;",
       "         = .FALSE.: do not accumulate the transformation."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in,out]",
       "         T is REAL array, dimension (LDT,N)",
       "         On entry, the upper quasi-triangular matrix T, in Schur",
       "         canonical form.",
       "         On exit, the updated matrix T, again in Schur canonical form."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "         On entry, if WANTQ is .TRUE., the orthogonal matrix Q.",
       "         On exit, if WANTQ is .TRUE., the updated matrix Q.",
       "         If WANTQ is .FALSE., Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= 1; and if WANTQ is .TRUE., LDQ >= N."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The index of the first row of the first block T11."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         The order of the first block T11. N1 = 0, 1 or 2."],
     "N2"=>
      ["[in]",
       "         N2 is INTEGER",
       "         The order of the second block T22. N2 = 0, 1 or 2."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         = 1: the transformed matrix T would be too far from Schur",
       "              form; the blocks are not swapped and T and Q are",
       "              unchanged."]}},
 "dpbsvx"=>
  {"summary"=>
    ["DPBSVX uses the Cholesky factorization A = U**T*U or A = L*L**T to",
     "compute the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite band matrix and X",
     "and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "dsytrd_sy2sb"=>
  {"summary"=>
    ["DSYTRD_SY2SB reduces a real symmetric matrix A to real symmetric",
     "band-diagonal form AB by a orthogonal similarity transformation:",
     "Q**T * A * Q = AB."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the reduced matrix if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0.",
       "         The reduced matrix is stored in the array AB."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the orthogonal",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the orthogonal matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AB"=>
      ["[out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On exit, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (N-KD)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension LWORK.",
       "         On exit, if INFO = 0, or if LWORK=-1, ",
       "         WORK(1) returns the size of LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK which should be calculated",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA.",
       "         LWORK_QUERY = N*KD + N*max(KD,FACTOPTNB) + 2*KD*KD",
       "         where FACTOPTNB is the blocking used by the QR or LQ",
       "         algorithm, usually FACTOPTNB=128 is a good choice otherwise",
       "         putting LWORK=-1 will provide the size of WORK."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zsptrf"=>
  {"summary"=>
    ["ZSPTRF computes the factorization of a complex symmetric matrix A",
     "stored in packed format using the Bunch-Kaufman diagonal pivoting",
     "method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L, stored as a packed triangular",
       "         matrix overwriting A (see below for further details)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "zgebrd"=>
  {"summary"=>
    ["ZGEBRD reduces a general complex M-by-N matrix A to upper or lower",
     "bidiagonal form B by a unitary transformation: Q**H * A * P = B.",
     "If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N general matrix to be reduced.",
       "         On exit,",
       "         if m >= n, the diagonal and the first superdiagonal are",
       "           overwritten with the upper bidiagonal matrix B; the",
       "           elements below the diagonal, with the array TAUQ, represent",
       "           the unitary matrix Q as a product of elementary",
       "           reflectors, and the elements above the first superdiagonal,",
       "           with the array TAUP, represent the unitary matrix P as",
       "           a product of elementary reflectors;",
       "         if m < n, the diagonal and the first subdiagonal are",
       "           overwritten with the lower bidiagonal matrix B; the",
       "           elements below the first subdiagonal, with the array TAUQ,",
       "           represent the unitary matrix Q as a product of",
       "           elementary reflectors, and the elements above the diagonal,",
       "           with the array TAUP, represent the unitary matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (min(M,N)-1)",
       "         The off-diagonal elements of the bidiagonal matrix B:",
       "         if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;",
       "         if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is COMPLEX*16 array dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix P. See Further Details."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,M,N).",
       "         For optimum performance LWORK >= (M+N)*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "sorg2r"=>
  {"summary"=>
    ["SORG2R generates an m by n real matrix Q with orthonormal columns,",
     "which is defined as the first n columns of a product of k elementary",
     "reflectors of order m",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by SGEQRF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the i-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by SGEQRF in the first k columns of its array",
       "         argument A.",
       "         On exit, the m-by-n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGEQRF."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "stpmlqt"=>
  {"summary"=>
    ["DTPMQRT applies a real orthogonal matrix Q obtained from a",
     "\"triangular-pentagonal\" real block reflector H to a general",
     "real matrix C, which consists of two blocks A and B."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size used for the storage of T.  K >= MB >= 1.",
       "         This must be the same value of MB used to generate T",
       "         in DTPLQT."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension (LDA,K)",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DTPLQT in B.  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDV >= max(1,M);",
       "         if SIDE = 'R', LDV >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by DTPLQT, stored as a MB-by-K matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension",
       "         (LDA,N) if SIDE = 'L' or",
       "         (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         Q*C or Q**T*C or C*Q or C*Q**T.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         Q*C or Q**T*C or C*Q or C*Q**T.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array. The dimension of WORK is",
       "          N*MB if SIDE = 'L', or  M*MB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dsbev_2stage"=>
  {"summary"=>
    ["DSBEV_2STAGE computes all the eigenvalues and, optionally, eigenvectors of",
     "a real symmetric band matrix A using the 2stage technique for",
     "the reduction to tridiagonal."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension LWORK",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS + N",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "sgbequb"=>
  {"summary"=>
    ["SGBEQUB computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most",
     "the radix.",
     "R(i) and C(j) are restricted to be a power of the radix between",
     "SMLNUM = smallest safe number and BIGNUM = largest safe number.  Use",
     "of these scaling factors is not guaranteed to reduce the condition",
     "number of A but works well in practice.",
     "This routine differs from SGEEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled entries' magnitudes are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A.  LDAB >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is REAL array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is REAL array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is REAL",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is REAL",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "dlasrt"=>
  {"summary"=>
    ["Sort the numbers in D in increasing order (if ID = 'I') or",
     "in decreasing order (if ID = 'D' ).",
     "Use Quick Sort, reverting to Insertion sort on arrays of",
     "size <= 20. Dimension of STACK limits N to about 2**32."],
   "param"=>
    {"ID"=>
      ["[in]",
       "         ID is CHARACTER*1",
       "         = 'I': sort D in increasing order;",
       "         = 'D': sort D in decreasing order."],
     "N"=>
      ["[in]", "         N is INTEGER", "         The length of the array D."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the array to be sorted.",
       "         On exit, D has been sorted into increasing order",
       "         (D(1) <= ... <= D(N) ) or into decreasing order",
       "         (D(1) >= ... >= D(N) ), depending on ID."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgelqt3"=>
  {"summary"=>
    ["DGELQT3 recursively computes a LQ factorization of a real M-by-N",
     "matrix A, using the compact WY representation of Q.",
     "Based on the algorithm of Elmroth and Gustavson,",
     "IBM J. Res. Develop. Vol 44 No. 4 July 2000."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M =< N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the real M-by-N matrix A.  On exit, the elements on and",
       "         below the diagonal contain the N-by-N lower triangular matrix L; the",
       "         elements above the diagonal are the rows of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zpbsv"=>
  {"summary"=>
    ["ZPBSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite band matrix and X",
     "and B are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L * L**H,  if UPLO = 'L',",
     "where U is an upper triangular band matrix, and L is a lower",
     "triangular band matrix, with the same number of superdiagonals or",
     "subdiagonals as A.  The factored form of A is then used to solve the",
     "system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(KD+1+i-j,j) = A(i,j) for max(1,j-KD)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(N,j+KD).",
       "         See below for further details.",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H *U or A = L*L**H of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "dgetrf"=>
  {"summary"=>
    ["DGETRF computes an LU factorization of a general M-by-N matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the right-looking Level 3 BLAS version of the algorithm."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "cgemqr"=>
  {"summary"=>
    ["CGEMQR overwrites the general real M-by-N matrix C with",
     "                     SIDE = 'L'     SIDE = 'R'",
     "     TRANS = 'N':      Q * C          C * Q",
     "     TRANS = 'T':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product",
     "of blocked elementary reflectors computed by tall skinny",
     "QR factorization (CGEQR)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,K)",
       "         Part of the data structure to represent Q as returned by CGEQR."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension (MAX(5,TSIZE)).",
       "         Part of the data structure to represent Q as returned by CGEQR."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         The dimension of the array T. TSIZE >= 5."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]", "        (workspace) COMPLEX array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed. The routine",
       "         only calculates the size of the WORK array, returns this",
       "         value as WORK(1), and no error message related to WORK ",
       "         is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgbsvxx"=>
  {"summary"=>
    ["   SGBSVXX uses the LU factorization to compute the solution to a",
     "   real system of linear equations  A * X = B,  where A is an",
     "   N-by-N matrix and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. SGBSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   SGBSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   SGBSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what SGBSVXX would itself produce."],
   "param"=>nil},
 "dpprfs"=>
  {"summary"=>
    ["DPPRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric positive definite",
     "and packed, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "AFP"=>
      ["[in]",
       "         AFP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, as computed by DPPTRF/ZPPTRF,",
       "         packed columnwise in a linear array in the same format as A",
       "         (see AP)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by DPPTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "iparmq"=>
  {"summary"=>
    ["     This program sets problem and machine dependent parameters",
     "     useful for xHSEQR and related subroutines for eigenvalue",
     "     problems. It is called whenever",
     "     IPARMQ is called with 12 <= ISPEC <= 16"],
   "param"=>
    {"ISPEC"=>
      ["[in]",
       "         ISPEC is integer scalar",
       "             ISPEC specifies which tunable parameter IPARMQ should",
       "             return.",
       "             ISPEC=12: (INMIN)  Matrices of order nmin or less",
       "                       are sent directly to xLAHQR, the implicit",
       "                       double shift QR algorithm.  NMIN must be",
       "                       at least 11.",
       "             ISPEC=13: (INWIN)  Size of the deflation window.",
       "                       This is best set greater than or equal to",
       "                       the number of simultaneous shifts NS.",
       "                       Larger matrices benefit from larger deflation",
       "                       windows.",
       "             ISPEC=14: (INIBL) Determines when to stop nibbling and",
       "                       invest in an (expensive) multi-shift QR sweep.",
       "                       If the aggressive early deflation subroutine",
       "                       finds LD converged eigenvalues from an order",
       "                       NW deflation window and LD.GT.(NW*NIBBLE)/100,",
       "                       then the next QR sweep is skipped and early",
       "                       deflation is applied immediately to the",
       "                       remaining active diagonal block.  Setting",
       "                       IPARMQ(ISPEC=14) = 0 causes TTQRE to skip a",
       "                       multi-shift QR sweep whenever early deflation",
       "                       finds a converged eigenvalue.  Setting",
       "                       IPARMQ(ISPEC=14) greater than or equal to 100",
       "                       prevents TTQRE from skipping a multi-shift",
       "                       QR sweep.",
       "             ISPEC=15: (NSHFTS) The number of simultaneous shifts in",
       "                       a multi-shift QR iteration.",
       "             ISPEC=16: (IACC22) IPARMQ is set to 0, 1 or 2 with the",
       "                       following meanings.",
       "                       0:  During the multi-shift QR/QZ sweep,",
       "                           blocked eigenvalue reordering, blocked",
       "                           Hessenberg-triangular reduction,",
       "                           reflections and/or rotations are not",
       "                           accumulated when updating the",
       "                           far-from-diagonal matrix entries.",
       "                       1:  During the multi-shift QR/QZ sweep,",
       "                           blocked eigenvalue reordering, blocked",
       "                           Hessenberg-triangular reduction,",
       "                           reflections and/or rotations are",
       "                           accumulated, and matrix-matrix",
       "                           multiplication is used to update the",
       "                           far-from-diagonal matrix entries.",
       "                       2:  During the multi-shift QR/QZ sweep,",
       "                           blocked eigenvalue reordering, blocked",
       "                           Hessenberg-triangular reduction,",
       "                           reflections and/or rotations are",
       "                           accumulated, and 2-by-2 block structure",
       "                           is exploited during matrix-matrix",
       "                           multiplies.",
       "                       (If xTRMM is slower than xGEMM, then",
       "                       IPARMQ(ISPEC=16)=1 may be more efficient than",
       "                       IPARMQ(ISPEC=16)=2 despite the greater level of",
       "                       arithmetic work implied by the latter choice.)"],
     "NAME"=>
      ["[in]",
       "         NAME is character string",
       "              Name of the calling subroutine"],
     "OPTS"=>
      ["[in]",
       "         OPTS is character string",
       "              This is a concatenation of the string arguments to",
       "              TTQRE."],
     "N"=>
      ["[in]",
       "         N is integer scalar",
       "              N is the order of the Hessenberg matrix H."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "              It is assumed that H is already upper triangular",
       "              in rows and columns 1:ILO-1 and IHI+1:N."],
     "LWORK"=>
      ["[in]",
       "         LWORK is integer scalar",
       "              The amount of workspace available."]}},
 "cunbdb2"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= min(M-P,Q,M-Q)."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is REAL array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is COMPLEX array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is COMPLEX array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is COMPLEX array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zsytrf"=>
  {"summary"=>
    ["ZSYTRF computes the factorization of a complex symmetric matrix A",
     "using the Bunch-Kaufman diagonal pivoting method.  The form of the",
     "factorization is",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "dsytri_3"=>
  {"summary"=>
    ["DSYTRI_3 computes the inverse of a real symmetric indefinite",
     "matrix A using the factorization computed by DSYTRF_RK or DSYTRF_BK:",
     "    A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "DSYTRI_3 sets the leading dimension of the workspace  before calling",
     "DSYTRI_3X that actually computes the inverse.  This is the blocked",
     "version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by DSYTRF_RK and DSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the symmetric inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF_RK or DSYTRF_BK."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (N+NB+1)*(NB+3).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK. LWORK >= (N+NB+1)*(NB+3).",
       "         If LDWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the optimal",
       "         size of the WORK array, returns this value as the first",
       "         entry of the WORK array, and no error message related to",
       "         LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "ztpqrt2"=>
  {"summary"=>
    ["ZTPQRT2 computes a QR factorization of a complex \"triangular-pentagonal\"",
     "matrix C, which is composed of a triangular block A and pentagonal block B,",
     "using the compact WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of",
       "         the triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the upper trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the upper triangular N-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first M-L rows",
       "         are rectangular, and the last L rows are upper trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor T of the block reflector.",
       "         See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "cheevd"=>
  {"summary"=>
    ["CHEEVD computes all eigenvalues and, optionally, eigenvectors of a",
     "complex Hermitian matrix A.  If eigenvectors are desired, it uses a",
     "divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.",
       "         If N <= 1,                LWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LWORK must be at least N + 1.",
       "         If JOBZ  = 'V' and N > 1, LWORK must be at least 2*N + N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array,",
       "                                        dimension (LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If N <= 1,                LRWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LRWORK must be at least N.",
       "         If JOBZ  = 'V' and N > 1, LRWORK must be at least",
       "                        1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i and JOBZ = 'N', then the algorithm failed",
       "               to converge; i off-diagonal elements of an intermediate",
       "               tridiagonal form did not converge to zero;",
       "               if INFO = i and JOBZ = 'V', then the algorithm failed",
       "               to compute an eigenvalue while working on the submatrix",
       "               lying in rows and columns INFO/(N+1) through",
       "               mod(INFO,N+1)."]}},
 "slatrz"=>
  {"summary"=>
    ["SLATRZ factors the M-by-(M+L) real upper trapezoidal matrix",
     "[ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R  0 ) * Z, by means",
     "of orthogonal transformations.  Z is an (M+L)-by-(M+L) orthogonal",
     "matrix and, R and A1 are M-by-M upper triangular matrices."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing the",
       "         meaningful part of the Householder vectors. N-M >= L >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the leading M-by-N upper trapezoidal part of the",
       "         array A must contain the matrix to be factorized.",
       "         On exit, the leading M-by-M upper triangular part of A",
       "         contains the upper triangular matrix R, and elements N-L+1 to",
       "         N of the first M rows of A, with the array TAU, represent the",
       "         orthogonal matrix Z as a product of M elementary reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (M)",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (M)"]}},
 "sgels"=>
  {"summary"=>
    ["SGELS solves overdetermined or underdetermined real linear systems",
     "involving an M-by-N matrix A, or its transpose, using a QR or LQ",
     "factorization of A.  It is assumed that A has full rank.",
     "The following options are provided:",
     "1. If TRANS = 'N' and m >= n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A*X ||.",
     "2. If TRANS = 'N' and m < n:  find the minimum norm solution of",
     "   an underdetermined system A * X = B.",
     "3. If TRANS = 'T' and m >= n:  find the minimum norm solution of",
     "   an underdetermined system A**T * X = B.",
     "4. If TRANS = 'T' and m < n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A**T * X ||.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': the linear system involves A;",
       "         = 'T': the linear system involves A**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of the matrices B and X. NRHS >=0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "           if M >= N, A is overwritten by details of its QR",
       "                      factorization as returned by SGEQRF;",
       "           if M <  N, A is overwritten by details of its LQ",
       "                      factorization as returned by SGELQF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the matrix B of right hand side vectors, stored",
       "         columnwise; B is M-by-NRHS if TRANS = 'N', or N-by-NRHS",
       "         if TRANS = 'T'.",
       "         On exit, if INFO = 0, B is overwritten by the solution",
       "         vectors, stored columnwise:",
       "         if TRANS = 'N' and m >= n, rows 1 to n of B contain the least",
       "         squares solution vectors; the residual sum of squares for the",
       "         solution in each column is given by the sum of squares of",
       "         elements N+1 to M in that column;",
       "         if TRANS = 'N' and m < n, rows 1 to N of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'T' and m >= n, rows 1 to M of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'T' and m < n, rows 1 to M of B contain the",
       "         least squares solution vectors; the residual sum of squares",
       "         for the solution in each column is given by the sum of",
       "         squares of elements M+1 to N in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= MAX(1,M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= max( 1, MN + max( MN, NRHS ) ).",
       "         For optimal performance,",
       "         LWORK >= max( 1, MN + max( MN, NRHS )*NB ).",
       "         where MN = min(M,N) and NB is the optimum block size.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO =  i, the i-th diagonal element of the",
       "               triangular factor of A is zero, so that A does not have",
       "               full rank; the least squares solution could not be",
       "               computed."]}},
 "zsysvx"=>
  {"summary"=>
    ["ZSYSVX uses the diagonal pivoting factorization to compute the",
     "solution to a complex system of linear equations A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "ssyequb"=>
  {"summary"=>
    ["SSYEQUB computes row and column scalings intended to equilibrate a",
     "symmetric matrix A (with respect to the Euclidean norm) and reduce",
     "its condition number. The scale factors S are computed by the BIN",
     "algorithm (see references) so that the scaled matrix B with elements",
     "B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of",
     "the smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The N-by-N symmetric matrix whose scaling factors are to be",
       "         computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is REAL",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i). If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Largest absolute value of any matrix element. If AMAX is",
       "         very close to overflow or very close to underflow, the",
       "         matrix should be scaled."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "chgeqz"=>
  {"summary"=>
    ["CHGEQZ computes the eigenvalues of a complex matrix pair (H,T),",
     "where H is an upper Hessenberg matrix and T is upper triangular,",
     "using the single-shift QZ method.",
     "Matrix pairs of this type are produced by the reduction to",
     "generalized upper Hessenberg form of a complex matrix pair (A,B):",
     "   A = Q1*H*Z1**H,  B = Q1*T*Z1**H,",
     "as computed by CGGHRD.",
     "If JOB='S', then the Hessenberg-triangular pair (H,T) is",
     "also reduced to generalized Schur form,",
     "   H = Q*S*Z**H,  T = Q*P*Z**H,",
     "where Q and Z are unitary matrices and S and P are upper triangular.",
     "Optionally, the unitary matrix Q from the generalized Schur",
     "factorization may be postmultiplied into an input matrix Q1, and the",
     "unitary matrix Z may be postmultiplied into an input matrix Z1.",
     "If Q1 and Z1 are the unitary matrices from CGGHRD that reduced",
     "the matrix pair (A,B) to generalized Hessenberg form, then the output",
     "matrices Q1*Q and Z1*Z are the unitary factors from the generalized",
     "Schur factorization of (A,B):",
     "   A = (Q1*Q)*S*(Z1*Z)**H,  B = (Q1*Q)*P*(Z1*Z)**H.",
     "To avoid overflow, eigenvalues of the matrix pair (H,T)",
     "(equivalently, of (A,B)) are computed as a pair of complex values",
     "(alpha,beta).  If beta is nonzero, lambda = alpha / beta is an",
     "eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP)",
     "   A*x = lambda*B*x",
     "and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the",
     "alternate form of the GNEP",
     "   mu*A*y = B*y.",
     "The values of alpha and beta for the i-th eigenvalue can be read",
     "directly from the generalized Schur form:  alpha = S(i,i),",
     "beta = P(i,i).",
     "Ref: C.B. Moler & G.W. Stewart, \"An Algorithm for Generalized Matrix",
     "     Eigenvalue Problems\", SIAM J. Numer. Anal., 10(1973),",
     "     pp. 241--256."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         = 'E': Compute eigenvalues only;",
       "         = 'S': Computer eigenvalues and the Schur form."],
     "COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': Left Schur vectors (Q) are not computed;",
       "         = 'I': Q is initialized to the unit matrix and the matrix Q",
       "                of left Schur vectors of (H,T) is returned;",
       "         = 'V': Q must contain a unitary matrix Q1 on entry and",
       "                the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': Right Schur vectors (Z) are not computed;",
       "         = 'I': Q is initialized to the unit matrix and the matrix Z",
       "                of right Schur vectors of (H,T) is returned;",
       "         = 'V': Z must contain a unitary matrix Z1 on entry and",
       "                the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices H, T, Q, and Z.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of H which are in",
       "         Hessenberg form.  It is assumed that A is already upper",
       "         triangular in rows and columns 1:ILO-1 and IHI+1:N.",
       "         If N > 0, 1 <= ILO <= IHI <= N; if N = 0, ILO=1 and IHI=0."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX array, dimension (LDH, N)",
       "         On entry, the N-by-N upper Hessenberg matrix H.",
       "         On exit, if JOB = 'S', H contains the upper triangular",
       "         matrix S from the generalized Schur factorization.",
       "         If JOB = 'E', the diagonal of H matches that of S, but",
       "         the rest of H is unspecified."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max( 1, N )."],
     "T"=>
      ["[in,out]",
       "         T is COMPLEX array, dimension (LDT, N)",
       "         On entry, the N-by-N upper triangular matrix T.",
       "         On exit, if JOB = 'S', T contains the upper triangular",
       "         matrix P from the generalized Schur factorization.",
       "         If JOB = 'E', the diagonal of T matches that of P, but",
       "         the rest of T is unspecified."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max( 1, N )."],
     "ALPHA"=>
      ["[out]",
       "         ALPHA is COMPLEX array, dimension (N)",
       "         The complex scalars alpha that define the eigenvalues of",
       "         GNEP.  ALPHA(i) = S(i,i) in the generalized Schur",
       "         factorization."],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX array, dimension (N)",
       "         The real non-negative scalars beta that define the",
       "         eigenvalues of GNEP.  BETA(i) = P(i,i) in the generalized",
       "         Schur factorization.",
       "         Together, the quantities alpha = ALPHA(j) and beta = BETA(j)",
       "         represent the j-th eigenvalue of the matrix pair (A,B), in",
       "         one of the forms lambda = alpha/beta or mu = beta/alpha.",
       "         Since either lambda or mu may overflow, they should not,",
       "         in general, be computed."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the unitary matrix Q1 used in the",
       "         reduction of (A,B) to generalized Hessenberg form.",
       "         On exit, if COMPQ = 'I', the unitary matrix of left Schur",
       "         vectors of (H,T), and if COMPQ = 'V', the unitary matrix of",
       "         left Schur vectors of (A,B).",
       "         Not referenced if COMPQ = 'N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= 1.",
       "         If COMPQ='V' or 'I', then LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the unitary matrix Z1 used in the",
       "         reduction of (A,B) to generalized Hessenberg form.",
       "         On exit, if COMPZ = 'I', the unitary matrix of right Schur",
       "         vectors of (H,T), and if COMPZ = 'V', the unitary matrix of",
       "         right Schur vectors of (A,B).",
       "         Not referenced if COMPZ = 'N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1.",
       "         If COMPZ='V' or 'I', then LDZ >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO >= 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         = 1,...,N: the QZ iteration did not converge.  (H,T) is not",
       "                    in Schur form, but ALPHA(i) and BETA(i),",
       "                    i=INFO+1,...,N should be correct.",
       "         = N+1,...,2*N: the shift calculation failed.  (H,T) is not",
       "                    in Schur form, but ALPHA(i) and BETA(i),",
       "                    i=INFO-N+1,...,N should be correct."]}},
 "slabad"=>
  {"summary"=>
    ["SLABAD takes as input the values computed by SLAMCH for underflow and",
     "overflow, and returns the square root of each of these values if the",
     "log of LARGE is sufficiently large.  This subroutine is intended to",
     "identify machines with a large exponent range, such as the Crays, and",
     "redefine the underflow and overflow limits to be the square roots of",
     "the values computed by SLAMCH.  This subroutine is needed because",
     "SLAMCH does not compensate for poor arithmetic in the upper half of",
     "the exponent range, as is found on a Cray."],
   "param"=>
    {"SMALL"=>
      ["[in,out]",
       "         SMALL is REAL",
       "         On entry, the underflow threshold as computed by SLAMCH.",
       "         On exit, if LOG10(LARGE) is sufficiently large, the square",
       "         root of SMALL, otherwise unchanged."],
     "LARGE"=>
      ["[in,out]",
       "         LARGE is REAL",
       "         On entry, the overflow threshold as computed by SLAMCH.",
       "         On exit, if LOG10(LARGE) is sufficiently large, the square",
       "         root of LARGE, otherwise unchanged."]}},
 "cgels"=>
  {"summary"=>
    ["CGELS solves overdetermined or underdetermined complex linear systems",
     "involving an M-by-N matrix A, or its conjugate-transpose, using a QR",
     "or LQ factorization of A.  It is assumed that A has full rank.",
     "The following options are provided:",
     "1. If TRANS = 'N' and m >= n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A*X ||.",
     "2. If TRANS = 'N' and m < n:  find the minimum norm solution of",
     "   an underdetermined system A * X = B.",
     "3. If TRANS = 'C' and m >= n:  find the minimum norm solution of",
     "   an underdetermined system A**H * X = B.",
     "4. If TRANS = 'C' and m < n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A**H * X ||.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': the linear system involves A;",
       "         = 'C': the linear system involves A**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of the matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "           if M >= N, A is overwritten by details of its QR",
       "                      factorization as returned by CGEQRF;",
       "           if M <  N, A is overwritten by details of its LQ",
       "                      factorization as returned by CGELQF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the matrix B of right hand side vectors, stored",
       "         columnwise; B is M-by-NRHS if TRANS = 'N', or N-by-NRHS",
       "         if TRANS = 'C'.",
       "         On exit, if INFO = 0, B is overwritten by the solution",
       "         vectors, stored columnwise:",
       "         if TRANS = 'N' and m >= n, rows 1 to n of B contain the least",
       "         squares solution vectors; the residual sum of squares for the",
       "         solution in each column is given by the sum of squares of the",
       "         modulus of elements N+1 to M in that column;",
       "         if TRANS = 'N' and m < n, rows 1 to N of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'C' and m >= n, rows 1 to M of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'C' and m < n, rows 1 to M of B contain the",
       "         least squares solution vectors; the residual sum of squares",
       "         for the solution in each column is given by the sum of",
       "         squares of the modulus of elements M+1 to N in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= MAX(1,M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= max( 1, MN + max( MN, NRHS ) ).",
       "         For optimal performance,",
       "         LWORK >= max( 1, MN + max( MN, NRHS )*NB ).",
       "         where MN = min(M,N) and NB is the optimum block size.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO =  i, the i-th diagonal element of the",
       "               triangular factor of A is zero, so that A does not have",
       "               full rank; the least squares solution could not be",
       "               computed."]}},
 "dsytrd_2stage"=>
  {"summary"=>
    ["DSYTRD_2STAGE reduces a real symmetric matrix A to real symmetric",
     "tridiagonal form T by a orthogonal similarity transformation:",
     "Q1**T Q2**T* A * Q2 * Q1 = T."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  No need for the Housholder representation, ",
       "                 in particular for the second stage (Band to",
       "                 tridiagonal) and thus LHOUS2 is of size max(1, 4*N);",
       "         = 'V':  the Householder representation is needed to ",
       "                 either generate Q1 Q2 or to apply Q1 Q2, ",
       "                 then LHOUS2 is to be queried and computed.",
       "                 (NOT AVAILABLE IN THIS RELEASE)."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the band superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         internal band-diagonal matrix AB, and the elements above ",
       "         the KD superdiagonal, with the array TAU, represent the orthogonal",
       "         matrix Q1 as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and band subdiagonal of A are over-",
       "         written by the corresponding elements of the internal band-diagonal",
       "         matrix AB, and the elements below the KD subdiagonal, with",
       "         the array TAU, represent the orthogonal matrix Q1 as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (N-KD)",
       "         The scalar factors of the elementary reflectors of ",
       "         the first stage (see Further Details)."],
     "HOUS2"=>
      ["[out]",
       "         HOUS2 is DOUBLE PRECISION array, dimension LHOUS2, that",
       "         store the Householder representation of the stage2",
       "         band to tridiagonal."],
     "LHOUS2"=>
      ["[in]",
       "         LHOUS2 is INTEGER",
       "         The dimension of the array HOUS2. LHOUS2 = MAX(1, dimension)",
       "         If LWORK = -1, or LHOUS2=-1,",
       "         then a query is assumed; the routine",
       "         only calculates the optimal size of the HOUS2 array, returns",
       "         this value as the first entry of the HOUS2 array, and no error",
       "         message related to LHOUS2 is issued by XERBLA.",
       "         LHOUS2 = MAX(1, dimension) where",
       "         dimension = 4*N if VECT='N'",
       "         not available now if VECT='H'"],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK = MAX(1, dimension)",
       "         If LWORK = -1, or LHOUS2=-1,",
       "         then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA.",
       "         LWORK = MAX(1, dimension) where",
       "         dimension   = max(stage1,stage2) + (KD+1)*N",
       "                     = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                       + max(2*KD*KD, KD*NTHREADS) ",
       "                       + (KD+1)*N ",
       "         where KD is the blocking size of the reduction,",
       "         FACTOPTNB is the blocking used by the QR or LQ",
       "         algorithm, usually FACTOPTNB=128 is a good choice",
       "         NTHREADS is the number of threads used when",
       "         openMP compilation is enabled, otherwise =1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dla_gerpvgrw"=>
  {"summary"=>
    ["DLA_GERPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A. NCOLS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by DGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."]}},
 "zgemqrt"=>
  {"summary"=>
    ["ZGEMQRT overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q C            C Q",
     "TRANS = 'C':    Q**H C            C Q**H",
     "where Q is a complex orthogonal matrix defined as the product of K",
     "elementary reflectors:",
     "      Q = H(1) H(2) . . . H(K) = I - V T V**H",
     "generated using the compact WY representation as returned by ZGEQRT.",
     "Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size used for the storage of T.  K >= NB >= 1.",
       "         This must be the same value of NB used to generate T",
       "         in CGEQRT."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension (LDV,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGEQRT in the first K columns of its array argument A."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by CGEQRT, stored as a NB-by-N matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q C, Q**H C, C Q**H or C Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array. The dimension of WORK is",
       "          N*NB if SIDE = 'L', or  M*NB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "stgex2"=>
  {"summary"=>
    ["STGEX2 swaps adjacent diagonal blocks (A11, B11) and (A22, B22)",
     "of size 1-by-1 or 2-by-2 in an upper (quasi) triangular matrix pair",
     "(A, B) by an orthogonal equivalence transformation.",
     "(A, B) must be in generalized real Schur canonical form (as returned",
     "by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2",
     "diagonal blocks. B is upper triangular.",
     "Optionally, the matrices Q and Z of generalized Schur vectors are",
     "updated.",
     "       Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T",
     "       Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T"],
   "param"=>
    {"WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL arrays, dimensions (LDA,N)",
       "         On entry, the matrix A in the pair (A, B).",
       "         On exit, the updated matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL arrays, dimensions (LDB,N)",
       "         On entry, the matrix B in the pair (A, B).",
       "         On exit, the updated matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDZ,N)",
       "         On entry, if WANTQ = .TRUE., the orthogonal matrix Q.",
       "         On exit, the updated matrix Q.",
       "         Not referenced if WANTQ = .FALSE.."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= 1.",
       "         If WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ,N)",
       "         On entry, if WANTZ =.TRUE., the orthogonal matrix Z.",
       "         On exit, the updated matrix Z.",
       "         Not referenced if WANTZ = .FALSE.."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1.",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The index to the first block (A11, B11). 1 <= J1 <= N."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         The order of the first block (A11, B11). N1 = 0, 1 or 2."],
     "N2"=>
      ["[in]",
       "         N2 is INTEGER",
       "         The order of the second block (A22, B22). N2 = 0, 1 or 2."],
     "WORK"=>
      ["[out]", "         WORK is REAL array, dimension (MAX(1,LWORK))."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >=  MAX( N*(N2+N1), (N2+N1)*(N2+N1)*2 )"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "           =0: Successful exit",
       "           >0: If INFO = 1, the transformed matrix (A, B) would be",
       "               too far from generalized Schur form; the blocks are",
       "               not swapped and (A, B) and (Q, Z) are unchanged.",
       "               The problem of swapping is too ill-conditioned.",
       "           <0: If INFO = -16: LWORK is too small. Appropriate value",
       "               for LWORK is returned in WORK(1)."]}},
 "dsfrk"=>
  {"summary"=>
    ["Level 3 BLAS like routine for C in RFP Format.",
     "DSFRK performs one of the symmetric rank--k operations",
     "   C := alpha*A*A**T + beta*C,",
     "or",
     "   C := alpha*A**T*A + beta*C,",
     "where alpha and beta are real scalars, C is an n--by--n symmetric",
     "matrix and A is an n--by--k matrix in the first case and a k--by--n",
     "matrix in the second case."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal Form of RFP A is stored;",
       "         = 'T':  The Transpose Form of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On  entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array C is to be referenced as",
       "          follows:",
       "             UPLO = 'U' or 'u'   Only the upper triangular part of C",
       "                                 is to be referenced.",
       "             UPLO = 'L' or 'l'   Only the lower triangular part of C",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "          On entry, TRANS specifies the operation to be performed as",
       "          follows:",
       "             TRANS = 'N' or 'n'   C := alpha*A*A**T + beta*C.",
       "             TRANS = 'T' or 't'   C := alpha*A**T*A + beta*C.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the order of the matrix C. N must be",
       "          at least zero.",
       "          Unchanged on exit."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "          On entry with TRANS = 'N' or 'n', K specifies the number",
       "          of  columns of the matrix A, and on entry with TRANS = 'T'",
       "          or 't', K specifies the number of rows of the matrix A. K",
       "          must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,ka)",
       "          where KA",
       "          is K  when TRANS = 'N' or 'n', and is N otherwise. Before",
       "          entry with TRANS = 'N' or 'n', the leading N--by--K part of",
       "          the array A must contain the matrix A, otherwise the leading",
       "          K--by--N part of the array A must contain the matrix A.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'",
       "          then  LDA must be at least  max( 1, n ), otherwise  LDA must",
       "          be at least  max( 1, k ).",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION",
       "          On entry, BETA specifies the scalar beta.",
       "          Unchanged on exit."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (NT)",
       "          NT = N*(N+1)/2. On entry, the symmetric matrix C in RFP",
       "          Format. RFP Format is described by TRANSR, UPLO and N."]}},
 "dsygv"=>
  {"summary"=>
    ["DSYGV computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be symmetric and B is also",
     "positive definite."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the symmetric positive definite matrix B.",
       "         If UPLO = 'U', the leading N-by-N upper triangular part of B",
       "         contains the upper triangular part of the matrix B.",
       "         If UPLO = 'L', the leading N-by-N lower triangular part of B",
       "         contains the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,3*N-1).",
       "         For optimal efficiency, LWORK >= (NB+2)*N,",
       "         where NB is the blocksize for DSYTRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  DPOTRF or DSYEV returned an error code:",
       "            <= N:  if INFO = i, DSYEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "dlag2s"=>
  {"summary"=>
    ["DLAG2S converts a DOUBLE PRECISION matrix, SA, to a SINGLE",
     "PRECISION matrix, A.",
     "RMAX is the overflow for the SINGLE PRECISION arithmetic",
     "DLAG2S checks that all the entries of A are between -RMAX and",
     "RMAX. If not the conversion is aborted and a flag is raised.",
     "This is an auxiliary routine so there is no argument checking."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of lines of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N coefficient matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "SA"=>
      ["[out]",
       "         SA is REAL array, dimension (LDSA,N)",
       "         On exit, if INFO=0, the M-by-N coefficient matrix SA; if",
       "         INFO>0, the content of SA is unspecified."],
     "LDSA"=>
      ["[in]",
       "         LDSA is INTEGER",
       "         The leading dimension of the array SA.  LDSA >= max(1,M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         = 1:  an entry of the matrix A is greater than the SINGLE",
       "               PRECISION overflow threshold, in this case, the content",
       "               of SA in exit is unspecified."]}},
 "clacgv"=>
  {"summary"=>["CLACGV conjugates a complex vector of length N."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The length of the vector X.  N >= 0."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension",
       "                        (1+(N-1)*abs(INCX))",
       "         On entry, the vector of length N to be conjugated.",
       "         On exit, X is overwritten with conjg(X)."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The spacing between successive elements of X."]}},
 "clamswlq"=>
  {"summary"=>
    ["   CLAMQRTS overwrites the general real M-by-N matrix C with",
     "                   SIDE = 'L'     SIDE = 'R'",
     "   TRANS = 'N':      Q * C          C * Q",
     "   TRANS = 'T':      Q**T * C       C * Q**T",
     "   where Q is a real orthogonal matrix defined as the product of blocked",
     "   elementary reflectors computed by short wide LQ",
     "   factorization (CLASWLQ)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         M >= K >= 0;"],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         M >= MB >= 1"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.",
       "               MB > M."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,K)",
       "         The i-th row must contain the vector which defines the blocked",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DLASWLQ in the first k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension",
       "         ( M * Number of blocks(CEIL(N-K/NB-K)),",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]", "        (workspace) COMPLEX array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,NB) * MB;",
       "         if SIDE = 'R', LWORK >= max(1,M) * MB.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dsytf2_rook"=>
  {"summary"=>
    ["DSYTF2_ROOK computes the factorization of a real symmetric matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**T is the transpose of U, and D is symmetric and",
     "block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "ilazlr"=>
  {"summary"=>["ILAZLR scans A for its last non-zero row."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."]}},
 "clatps"=>
  {"summary"=>
    ["CLATPS solves one of the triangular systems",
     "   A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b,",
     "with scaling to prevent overflow, where A is an upper or lower",
     "triangular matrix stored in packed form.  Here A**T denotes the",
     "transpose of A, A**H denotes the conjugate transpose of A, x and b",
     "are n-element vectors, and s is a scaling factor, usually less than",
     "or equal to 1, chosen so that the components of x will be less than",
     "the overflow threshold.  If the unscaled problem will not cause",
     "overflow, the Level 2 BLAS routine CTPSV is called. If the matrix A",
     "is singular (A(j,j) = 0 for some j), then s is set to 0 and a",
     "non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b     (No transpose)",
       "         = 'T':  Solve A**T * x = s*b  (Transpose)",
       "         = 'C':  Solve A**H * x = s*b  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is REAL array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "claqsb"=>
  {"summary"=>
    ["CLAQSB equilibrates a symmetric band matrix A using the scaling",
     "factors in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H *U or A = L*L**H of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is REAL",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "stpttf"=>
  {"summary"=>
    ["STPTTF copies a triangular matrix A from standard packed format (TP)",
     "to rectangular full packed format (TF)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF in Normal format is wanted;",
       "         = 'T':  ARF in Conjugate-transpose format is wanted."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "ARF"=>
      ["[out]",
       "         ARF is REAL array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgttrs"=>
  {"summary"=>
    ["CGTTRS solves one of the systems of equations",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B,",
     "with a tridiagonal matrix A using the LU factorization computed",
     "by CGTTRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations.",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is COMPLEX array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A."],
     "D"=>
      ["[in]",
       "         D is COMPLEX array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is COMPLEX array, dimension (N-1)",
       "         The (n-1) elements of the first super-diagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is COMPLEX array, dimension (N-2)",
       "         The (n-2) elements of the second super-diagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the matrix of right hand side vectors B.",
       "         On exit, B is overwritten by the solution vectors X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "ssysv_aa"=>
  {"summary"=>
    ["SSYSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "Aasen's algorithm is used to factor A as",
     "   A = U * T * U**T,  if UPLO = 'U', or",
     "   A = L * T * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is symmetric tridiagonal. The factored",
     "form of A is then used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the tridiagonal matrix T and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*T*U**T or A = L*T*L**T as computed by",
       "         SSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= MAX(1,2*N,3*N-2), and for",
       "         the best performance, LWORK >= MAX(1,N*NB), where NB is",
       "         the optimal blocksize for SSYTRF_AA.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "slarfx"=>
  {"summary"=>
    ["SLARFX applies a real elementary reflector H to a real m by n",
     "matrix C, from either the left or the right. H is represented in the",
     "form",
     "      H = I - tau * v * v**T",
     "where tau is a real scalar and v is a real vector.",
     "If tau = 0, then H is taken to be the unit matrix",
     "This version uses inline code if H has order < 11."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension (M) if SIDE = 'L'",
       "                                    or (N) if SIDE = 'R'",
       "         The vector v in the representation of H."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDA >= (1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension",
       "                     (N) if SIDE = 'L'",
       "                     or (M) if SIDE = 'R'",
       "         WORK is not referenced if H has order < 11."]}},
 "cla_lin_berr"=>
  {"summary"=>
    ["   CLA_LIN_BERR computes componentwise relative backward error from",
     "   the formula",
     "       max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
     "   where abs(Z) is the componentwise absolute value of the matrix",
     "   or vector Z."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NZ"=>
      ["[in]",
       "         NZ is INTEGER",
       "    We add (NZ+1)*SLAMCH( 'Safe minimum' ) to R(i) in the numerator to",
       "    guard against spuriously zero residuals. Default value is N."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices AYB, RES, and BERR.  NRHS >= 0."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX array, dimension (N,NRHS)",
       "    The residual matrix, i.e., the matrix R in the relative backward",
       "    error formula above."],
     "AYB"=>
      ["[in]",
       "         AYB is REAL array, dimension (N, NRHS)",
       "    The denominator in the relative backward error formula above, i.e.,",
       "    the matrix abs(op(A_s))*abs(Y) + abs(B_s). The matrices A, Y, and B",
       "    are from iterative refinement (see cla_gerfsx_extended.f)."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "    The componentwise relative backward error from the formula above."]}},
 "slaqps"=>
  {"summary"=>
    ["SLAQPS computes a step of QR factorization with column pivoting",
     "of a real M-by-N matrix A by using Blas-3.  It tries to factorize",
     "NB columns from A starting from the row OFFSET+1, and updates all",
     "of the matrix with Blas-3 xGEMM.",
     "In some cases, due to catastrophic cancellations, it cannot",
     "factorize NB columns.  Hence, the actual number of factorized",
     "columns is returned in KB.",
     "Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0"],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         The number of rows of A that have been factorized in",
       "         previous steps."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of columns to factorize."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns actually factorized."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, block A(OFFSET+1:M,1:KB) is the triangular",
       "         factor obtained and block A(1:OFFSET,1:N) has been",
       "         accordingly pivoted, but no factorized.",
       "         The rest of the matrix, block A(OFFSET+1:M,KB+1:N) has",
       "         been updated."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         JPVT(I) = K <==> Column K of the full matrix A has been",
       "         permuted into position I in AP."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (KB)",
       "         The scalar factors of the elementary reflectors."],
     "VN1"=>
      ["[in,out]",
       "         VN1 is REAL array, dimension (N)",
       "         The vector with the partial column norms."],
     "VN2"=>
      ["[in,out]",
       "         VN2 is REAL array, dimension (N)",
       "         The vector with the exact column norms."],
     "AUXV"=>
      ["[in,out]",
       "         AUXV is REAL array, dimension (NB)",
       "         Auxiliar vector."],
     "F"=>
      ["[in,out]",
       "         F is REAL array, dimension (LDF,NB)",
       "         Matrix F**T = L*Y**T*A."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the array F. LDF >= max(1,N)."]}},
 "dpptrs"=>
  {"summary"=>
    ["DPPTRS solves a system of linear equations A*X = B with a symmetric",
     "positive definite matrix A in packed storage using the Cholesky",
     "factorization A = U**T*U or A = L*L**T computed by DPPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, packed columnwise in a linear",
       "         array.  The j-th column of U or L is stored in the array AP",
       "         as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cla_heamv"=>
  {"summary"=>
    ["CLA_SYAMV  performs the matrix-vector operation",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "n by n symmetric matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is INTEGER",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array A is to be referenced as",
       "          follows:",
       "             UPLO = BLAS_UPPER   Only the upper triangular part of A",
       "                                 is to be referenced.",
       "             UPLO = BLAS_LOWER   Only the lower triangular part of A",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL .",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array of DIMENSION ( LDA, n ).",
       "          Before entry, the leading m by n part of the array A must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, n ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCX ) )",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL .",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCY ) )",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit."]}},
 "ctftri"=>
  {"summary"=>
    ["CTFTRI computes the inverse of a triangular matrix A stored in RFP",
     "format.",
     "This is a Level 3 BLAS version of the algorithm."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension ( N*(N+1)/2 );",
       "         On entry, the triangular matrix A in RFP format. RFP format",
       "         is described by TRANSR, UPLO, and N as follows: If TRANSR =",
       "         'N' then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'C' then RFP is",
       "         the Conjugate-transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the nt elements of",
       "         upper packed A; If UPLO = 'L' the RFP A contains the nt",
       "         elements of lower packed A. The LDA of RFP A is (N+1)/2 when",
       "         TRANSR = 'C'. When TRANSR is 'N' the LDA is N+1 when N is",
       "         even and N is odd. See the Note below for more details.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, A(i,i) is exactly zero.  The triangular",
       "              matrix is singular and its inverse can not be computed."]}},
 "zlatrz"=>
  {"summary"=>
    ["ZLATRZ factors the M-by-(M+L) complex upper trapezoidal matrix",
     "[ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R  0 ) * Z by means",
     "of unitary transformations, where  Z is an (M+L)-by-(M+L) unitary",
     "matrix and, R and A1 are M-by-M upper triangular matrices."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing the",
       "         meaningful part of the Householder vectors. N-M >= L >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the leading M-by-N upper trapezoidal part of the",
       "         array A must contain the matrix to be factorized.",
       "         On exit, the leading M-by-M upper triangular part of A",
       "         contains the upper triangular matrix R, and elements N-L+1 to",
       "         N of the first M rows of A, with the array TAU, represent the",
       "         unitary matrix Z as a product of M elementary reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (M)",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (M)"]}},
 "zlaqr5"=>
  {"summary"=>
    ["   ZLAQR5, called by ZLAQR0, performs a",
     "   single small-bulge multi-shift QR sweep."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is logical scalar",
       "            WANTT = .true. if the triangular Schur factor",
       "            is being computed.  WANTT is set to .false. otherwise."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is logical scalar",
       "            WANTZ = .true. if the unitary Schur factor is being",
       "            computed.  WANTZ is set to .false. otherwise."],
     "KACC22"=>
      ["[in]",
       "         KACC22 is integer with value 0, 1, or 2.",
       "            Specifies the computation mode of far-from-diagonal",
       "            orthogonal updates.",
       "       = 0: ZLAQR5 does not accumulate reflections and does not",
       "            use matrix-matrix multiply to update far-from-diagonal",
       "            matrix entries.",
       "       = 1: ZLAQR5 accumulates reflections and uses matrix-matrix",
       "            multiply to update the far-from-diagonal matrix entries.",
       "       = 2: ZLAQR5 accumulates reflections, uses matrix-matrix",
       "            multiply to update the far-from-diagonal matrix entries,",
       "            and takes advantage of 2-by-2 block structure during",
       "            matrix multiplies."],
     "N"=>
      ["[in]",
       "         N is integer scalar",
       "            N is the order of the Hessenberg matrix H upon which this",
       "            subroutine operates."],
     "KTOP"=>["[in]", "         KTOP is integer scalar"],
     "KBOT"=>
      ["[in]",
       "         KBOT is integer scalar",
       "            These are the first and last rows and columns of an",
       "            isolated diagonal block upon which the QR sweep is to be",
       "            applied. It is assumed without a check that",
       "                      either KTOP = 1  or   H(KTOP,KTOP-1) = 0",
       "            and",
       "                      either KBOT = N  or   H(KBOT+1,KBOT) = 0."],
     "NSHFTS"=>
      ["[in]",
       "         NSHFTS is integer scalar",
       "            NSHFTS gives the number of simultaneous shifts.  NSHFTS",
       "            must be positive and even."],
     "S"=>
      ["[in,out]",
       "         S is COMPLEX*16 array of size (NSHFTS)",
       "            S contains the shifts of origin that define the multi-",
       "            shift QR sweep.  On output S may be reordered."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX*16 array of size (LDH,N)",
       "            On input H contains a Hessenberg matrix.  On output a",
       "            multi-shift QR sweep with shifts SR(J)+i*SI(J) is applied",
       "            to the isolated diagonal block in rows and columns KTOP",
       "            through KBOT."],
     "LDH"=>
      ["[in]",
       "         LDH is integer scalar",
       "            LDH is the leading dimension of H just as declared in the",
       "            calling procedure.  LDH.GE.MAX(1,N)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "            Specify the rows of Z to which transformations must be",
       "            applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N"],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array of size (LDZ,IHIZ)",
       "            If WANTZ = .TRUE., then the QR Sweep unitary",
       "            similarity transformation is accumulated into",
       "            Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "            If WANTZ = .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer scalar",
       "            LDA is the leading dimension of Z just as declared in",
       "            the calling procedure. LDZ.GE.N."],
     "V"=>["[out]", "         V is COMPLEX*16 array of size (LDV,NSHFTS/2)"],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "            LDV is the leading dimension of V as declared in the",
       "            calling procedure.  LDV.GE.3."],
     "U"=>
      ["[out]",
       "         U is COMPLEX*16 array of size",
       "            (LDU,3*NSHFTS-3)"],
     "LDU"=>
      ["[in]",
       "         LDU is integer scalar",
       "            LDU is the leading dimension of U just as declared in the",
       "            in the calling subroutine.  LDU.GE.3*NSHFTS-3."],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "            NH is the number of columns in array WH available for",
       "            workspace. NH.GE.1."],
     "WH"=>["[out]", "         WH is COMPLEX*16 array of size (LDWH,NH)"],
     "LDWH"=>
      ["[in]",
       "         LDWH is integer scalar",
       "            Leading dimension of WH just as declared in the",
       "            calling procedure.  LDWH.GE.3*NSHFTS-3."],
     "NV"=>
      ["[in]",
       "         NV is integer scalar",
       "            NV is the number of rows in WV agailable for workspace.",
       "            NV.GE.1."],
     "WV"=>
      ["[out]",
       "         WV is COMPLEX*16 array of size",
       "            (LDWV,3*NSHFTS-3)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer scalar",
       "            LDWV is the leading dimension of WV as declared in the",
       "            in the calling subroutine.  LDWV.GE.NV."]}},
 "slaruv"=>
  {"summary"=>
    ["SLARUV returns a vector of n random real numbers from a uniform (0,1)",
     "distribution (n <= 128).",
     "This is an auxiliary routine called by SLARNV and CLARNV."],
   "param"=>
    {"ISEED"=>
      ["[in,out]",
       "         ISEED is INTEGER array, dimension (4)",
       "         On entry, the seed of the random number generator; the array",
       "         elements must be between 0 and 4095, and ISEED(4) must be",
       "         odd.",
       "         On exit, the seed is updated."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of random numbers to be generated. N <= 128."],
     "X"=>
      ["[out]",
       "         X is REAL array, dimension (N)",
       "         The generated random numbers."]}},
 "dgbrfsx"=>
  {"summary"=>
    ["   DGBRFSX improves the computed solution to a system of linear",
     "   equations and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED, R",
     "   and C below. In this case, the solution and error bounds returned",
     "   are for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "              diag(R).",
       "      = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "              by diag(C).",
       "      = 'B':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(R) * A * diag(C).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "    The original band matrix A, stored in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is DOUBLE PRECISION array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by DGBTRF.  U is stored as an upper triangular band",
       "    matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "    the multipliers used during the factorization are stored in",
       "    rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL*KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from DGETRF; for 1<=i<=N, row i of the",
       "    matrix was interchanged with row IPIV(i)."],
     "R"=>
      ["[in,out]",
       "         R is DOUBLE PRECISION array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'R' or 'B', A is",
       "    multiplied on the left by diag(R); if EQUED = 'N' or 'C', R",
       "    is not accessed.  R is an input argument if FACT = 'F';",
       "    otherwise, R is an output argument.  If FACT = 'F' and",
       "    EQUED = 'R' or 'B', each element of R must be positive.",
       "    If R is output, each element of R is a power of the radix.",
       "    If R is input, each element of R should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A.  If EQUED = 'C' or 'B', A is",
       "    multiplied on the right by diag(C); if EQUED = 'N' or 'R', C",
       "    is not accessed.  C is an input argument if FACT = 'F';",
       "    otherwise, C is an output argument.  If FACT = 'F' and",
       "    EQUED = 'C' or 'B', each element of C must be positive.",
       "    If C is output, each element of C is a power of the radix.",
       "    If C is input, each element of C should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by DGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is DOUBLE PRECISION array, dimension (NPARAMS)",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0D+0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "dgbrfs"=>
  {"summary"=>
    ["DGBRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is banded, and provides",
     "error bounds and backward error estimates for the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The original band matrix A, stored in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is DOUBLE PRECISION array, dimension (LDAFB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by DGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "         The leading dimension of the array AFB.  LDAFB >= 2*KL*KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from DGBTRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by DGBTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dsytd2"=>
  {"summary"=>
    ["DSYTD2 reduces a real symmetric matrix A to symmetric tridiagonal",
     "form T by an orthogonal similarity transformation: Q**T * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the orthogonal",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the orthogonal matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dormbr"=>
  {"summary"=>
    ["If VECT = 'Q', DORMBR overwrites the general real M-by-N matrix C",
     "with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "If VECT = 'P', DORMBR overwrites the general real M-by-N matrix C",
     "with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      P * C          C * P",
     "TRANS = 'T':      P**T * C       C * P**T",
     "Here Q and P**T are the orthogonal matrices determined by DGEBRD when",
     "reducing a real matrix A to bidiagonal form: A = Q * B * P**T. Q and",
     "P**T are defined as products of elementary reflectors H(i) and G(i)",
     "respectively.",
     "Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the",
     "order of the orthogonal matrix Q or P**T that is applied.",
     "If VECT = 'Q', A is assumed to have been an NQ-by-K matrix:",
     "if nq >= k, Q = H(1) H(2) . . . H(k);",
     "if nq < k, Q = H(1) H(2) . . . H(nq-1).",
     "If VECT = 'P', A is assumed to have been a K-by-NQ matrix:",
     "if k < nq, P = G(1) G(2) . . . G(k);",
     "if k >= nq, P = G(1) G(2) . . . G(nq-1)."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'Q': apply Q or Q**T;",
       "         = 'P': apply P or P**T."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q, Q**T, P or P**T from the Left;",
       "         = 'R': apply Q, Q**T, P or P**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q  or P;",
       "         = 'T':  Transpose, apply Q**T or P**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         If VECT = 'Q', the number of columns in the original",
       "         matrix reduced by DGEBRD.",
       "         If VECT = 'P', the number of rows in the original",
       "         matrix reduced by DGEBRD.",
       "         K >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension",
       "                               (LDA,min(nq,K)) if VECT = 'Q'",
       "                               (LDA,nq)        if VECT = 'P'",
       "         The vectors which define the elementary reflectors H(i) and",
       "         G(i), whose products determine the matrices Q and P, as",
       "         returned by DGEBRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If VECT = 'Q', LDA >= max(1,nq);",
       "         if VECT = 'P', LDA >= max(1,min(nq,K))."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (min(nq,K))",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i) or G(i) which determines Q or P, as returned",
       "         by DGEBRD in the array argument TAUQ or TAUP."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q",
       "         or P*C or P**T*C or C*P or C*P**T."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For optimum performance LWORK >= N*NB if SIDE = 'L', and",
       "         LWORK >= M*NB if SIDE = 'R', where NB is the optimal",
       "         blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sla_gerpvgrw"=>
  {"summary"=>
    ["SLA_GERPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A. NCOLS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by SGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."]}},
 "cgbsvxx"=>
  {"summary"=>
    ["   CGBSVXX uses the LU factorization to compute the solution to a",
     "   complex system of linear equations  A * X = B,  where A is an",
     "   N-by-N matrix and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. CGBSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   CGBSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   CGBSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what CGBSVXX would itself produce."],
   "param"=>nil},
 "zgeevx"=>
  {"summary"=>
    ["ZGEEVX computes for an N-by-N complex nonsymmetric matrix A, the",
     "eigenvalues and, optionally, the left and/or right eigenvectors.",
     "Optionally also, it computes a balancing transformation to improve",
     "the conditioning of the eigenvalues and eigenvectors (ILO, IHI,",
     "SCALE, and ABNRM), reciprocal condition numbers for the eigenvalues",
     "(RCONDE), and reciprocal condition numbers for the right",
     "eigenvectors (RCONDV).",
     "The right eigenvector v(j) of A satisfies",
     "                 A * v(j) = lambda(j) * v(j)",
     "where lambda(j) is its eigenvalue.",
     "The left eigenvector u(j) of A satisfies",
     "              u(j)**H * A = lambda(j) * u(j)**H",
     "where u(j)**H denotes the conjugate transpose of u(j).",
     "The computed eigenvectors are normalized to have Euclidean norm",
     "equal to 1 and largest component real.",
     "Balancing a matrix means permuting the rows and columns to make it",
     "more nearly upper triangular, and applying a diagonal similarity",
     "transformation D * A * D**(-1), where D is a diagonal matrix, to",
     "make its rows and columns closer in norm and the condition numbers",
     "of its eigenvalues and eigenvectors smaller.  The computed",
     "reciprocal condition numbers correspond to the balanced matrix.",
     "Permuting rows and columns will not change the condition numbers",
     "(in exact arithmetic) but diagonal scaling will.  For further",
     "explanation of balancing, see section 4.10.2 of the LAPACK",
     "Users' Guide."],
   "param"=>
    {"BALANC"=>
      ["[in]",
       "         BALANC is CHARACTER*1",
       "         Indicates how the input matrix should be diagonally scaled",
       "         and/or permuted to improve the conditioning of its",
       "         eigenvalues.",
       "         = 'N': Do not diagonally scale or permute;",
       "         = 'P': Perform permutations to make the matrix more nearly",
       "                upper triangular. Do not diagonally scale;",
       "         = 'S': Diagonally scale the matrix, ie. replace A by",
       "                D*A*D**(-1), where D is a diagonal matrix chosen",
       "                to make the rows and columns of A more equal in",
       "                norm. Do not permute;",
       "         = 'B': Both diagonally scale and permute A.",
       "         Computed reciprocal condition numbers will be for the matrix",
       "         after balancing and/or permuting. Permuting does not change",
       "         condition numbers (in exact arithmetic), but balancing does."],
     "JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N': left eigenvectors of A are not computed;",
       "         = 'V': left eigenvectors of A are computed.",
       "         If SENSE = 'E' or 'B', JOBVL must = 'V'."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N': right eigenvectors of A are not computed;",
       "         = 'V': right eigenvectors of A are computed.",
       "         If SENSE = 'E' or 'B', JOBVR must = 'V'."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': None are computed;",
       "         = 'E': Computed for eigenvalues only;",
       "         = 'V': Computed for right eigenvectors only;",
       "         = 'B': Computed for eigenvalues and right eigenvectors.",
       "         If SENSE = 'E' or 'B', both left and right eigenvectors",
       "         must also be computed (JOBVL = 'V' and JOBVR = 'V')."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten.  If JOBVL = 'V' or",
       "         JOBVR = 'V', A contains the Schur form of the balanced",
       "         version of the matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX*16 array, dimension (N)",
       "         W contains the computed eigenvalues."],
     "VL"=>
      ["[out]",
       "         VL is COMPLEX*16 array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order",
       "         as their eigenvalues.",
       "         If JOBVL = 'N', VL is not referenced.",
       "         u(j) = VL(:,j), the j-th column of VL."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1; if",
       "         JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is COMPLEX*16 array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order",
       "         as their eigenvalues.",
       "         If JOBVR = 'N', VR is not referenced.",
       "         v(j) = VR(:,j), the j-th column of VR."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1; if",
       "         JOBVR = 'V', LDVR >= N."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are integer values determined when A was",
       "         balanced.  The balanced A(i,j) = 0 if I > J and",
       "         J = 1,...,ILO-1 or I = IHI+1,...,N."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         when balancing A.  If P(j) is the index of the row and column",
       "         interchanged with row and column j, and D(j) is the scaling",
       "         factor applied to row and column j, then",
       "         SCALE(J) = P(J),    for J = 1,...,ILO-1",
       "                  = D(J),    for J = ILO,...,IHI",
       "                  = P(J)     for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "ABNRM"=>
      ["[out]",
       "         ABNRM is DOUBLE PRECISION",
       "         The one-norm of the balanced matrix (the maximum",
       "         of the sum of absolute values of elements of any column)."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is DOUBLE PRECISION array, dimension (N)",
       "         RCONDE(j) is the reciprocal condition number of the j-th",
       "         eigenvalue."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is DOUBLE PRECISION array, dimension (N)",
       "         RCONDV(j) is the reciprocal condition number of the j-th",
       "         right eigenvector."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  If SENSE = 'N' or 'E',",
       "         LWORK >= max(1,2*N), and if SENSE = 'V' or 'B',",
       "         LWORK >= N*N+2*N.",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the QR algorithm failed to compute all the",
       "               eigenvalues, and no eigenvectors or condition numbers",
       "               have been computed; elements 1:ILO-1 and i+1:N of W",
       "               contain eigenvalues which have converged."]}},
 "cposvx"=>
  {"summary"=>
    ["CPOSVX uses the Cholesky factorization A = U**H*U or A = L*L**H to",
     "compute the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite matrix and X and B",
     "are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "zhetrd_he2hb"=>
  {"summary"=>
    ["ZHETRD_HE2HB reduces a complex Hermitian matrix A to complex Hermitian",
     "band-diagonal form AB by a unitary similarity transformation:",
     "Q**H * A * Q = AB."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the reduced matrix if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0.",
       "         The reduced matrix is stored in the array AB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the unitary",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the unitary matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AB"=>
      ["[out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On exit, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (N-KD)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension LWORK.",
       "         On exit, if INFO = 0, or if LWORK=-1, ",
       "         WORK(1) returns the size of LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK which should be calculated",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA.",
       "         LWORK_QUERY = N*KD + N*max(KD,FACTOPTNB) + 2*KD*KD",
       "         where FACTOPTNB is the blocking used by the QR or LQ",
       "         algorithm, usually FACTOPTNB=128 is a good choice otherwise",
       "         putting LWORK=-1 will provide the size of WORK."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zunghr"=>
  {"summary"=>
    ["ZUNGHR generates a complex unitary matrix Q which is defined as the",
     "product of IHI-ILO elementary reflectors of order N, as returned by",
     "ZGEHRD:",
     "Q = H(ilo) H(ilo+1) . . . H(ihi-1)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI must have the same values as in the previous call",
       "         of ZGEHRD. Q is equal to the unit matrix except in the",
       "         submatrix Q(ilo+1:ihi,ilo+1:ihi).",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by ZGEHRD.",
       "         On exit, the N-by-N unitary matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGEHRD."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= IHI-ILO.",
       "         For optimum performance LWORK >= (IHI-ILO)*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ssytrf"=>
  {"summary"=>
    ["SSYTRF computes the factorization of a real symmetric matrix A using",
     "the Bunch-Kaufman diagonal pivoting method.  The form of the",
     "factorization is",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "ctpttf"=>
  {"summary"=>
    ["CTPTTF copies a triangular matrix A from standard packed format (TP)",
     "to rectangular full packed format (TF)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF in Normal format is wanted;",
       "         = 'C':  ARF in Conjugate-transpose format is wanted."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "ARF"=>
      ["[out]",
       "         ARF is COMPLEX array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaqr2"=>
  {"summary"=>
    ["   DLAQR2 is identical to DLAQR3 except that it avoids",
     "   recursion by calling DLAHQR instead of DLAQR4.",
     "   Aggressive early deflation:",
     "   This subroutine accepts as input an upper Hessenberg matrix",
     "   H and performs an orthogonal similarity transformation",
     "   designed to detect and deflate fully converged eigenvalues from",
     "   a trailing principal submatrix.  On output H has been over-",
     "   written by a new Hessenberg matrix that is a perturbation of",
     "   an orthogonal similarity transformation of H.  It is to be",
     "   hoped that the final version of H has many zero subdiagonal",
     "   entries."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         If .TRUE., then the Hessenberg matrix H is fully updated",
       "         so that the quasi-triangular Schur factor may be",
       "         computed (in cooperation with the calling subroutine).",
       "         If .FALSE., then only enough of H is updated to preserve",
       "         the eigenvalues."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         If .TRUE., then the orthogonal matrix Z is updated so",
       "         so that the orthogonal Schur factor may be computed",
       "         (in cooperation with the calling subroutine).",
       "         If .FALSE., then Z is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H and (if WANTZ is .TRUE.) the",
       "         order of the orthogonal matrix Z."],
     "KTOP"=>
      ["[in]",
       "         KTOP is INTEGER",
       "         It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.",
       "         KBOT and KTOP together determine an isolated block",
       "         along the diagonal of the Hessenberg matrix."],
     "KBOT"=>
      ["[in]",
       "         KBOT is INTEGER",
       "         It is assumed without a check that either",
       "         KBOT = N or H(KBOT+1,KBOT)=0.  KBOT and KTOP together",
       "         determine an isolated block along the diagonal of the",
       "         Hessenberg matrix."],
     "NW"=>
      ["[in]",
       "         NW is INTEGER",
       "         Deflation window size.  1 .LE. NW .LE. (KBOT-KTOP+1)."],
     "H"=>
      ["[in,out]",
       "         H is DOUBLE PRECISION array, dimension (LDH,N)",
       "         On input the initial N-by-N section of H stores the",
       "         Hessenberg matrix undergoing aggressive early deflation.",
       "         On output H has been transformed by an orthogonal",
       "         similarity transformation, perturbed, and the returned",
       "         to Hessenberg form that (it is to be hoped) has some",
       "         zero subdiagonal entries."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "         Leading dimension of H just as declared in the calling",
       "         subroutine.  N .LE. LDH"],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ,N)",
       "         IF WANTZ is .TRUE., then on output, the orthogonal",
       "         similarity transformation mentioned above has been",
       "         accumulated into Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "         If WANTZ is .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer",
       "         The leading dimension of Z just as declared in the",
       "         calling subroutine.  1 .LE. LDZ."],
     "NS"=>
      ["[out]",
       "         NS is integer",
       "         The number of unconverged (ie approximate) eigenvalues",
       "         returned in SR and SI that may be used as shifts by the",
       "         calling subroutine."],
     "ND"=>
      ["[out]",
       "         ND is integer",
       "         The number of converged eigenvalues uncovered by this",
       "         subroutine."],
     "SR"=>
      ["[out]", "         SR is DOUBLE PRECISION array, dimension (KBOT)"],
     "SI"=>
      ["[out]",
       "         SI is DOUBLE PRECISION array, dimension (KBOT)",
       "         On output, the real and imaginary parts of approximate",
       "         eigenvalues that may be used for shifts are stored in",
       "         SR(KBOT-ND-NS+1) through SR(KBOT-ND) and",
       "         SI(KBOT-ND-NS+1) through SI(KBOT-ND), respectively.",
       "         The real and imaginary parts of converged eigenvalues",
       "         are stored in SR(KBOT-ND+1) through SR(KBOT) and",
       "         SI(KBOT-ND+1) through SI(KBOT), respectively."],
     "V"=>
      ["[out]",
       "         V is DOUBLE PRECISION array, dimension (LDV,NW)",
       "         An NW-by-NW work array."],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "         The leading dimension of V just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "         The number of columns of T.  NH.GE.NW."],
     "T"=>
      ["[out]", "         T is DOUBLE PRECISION array, dimension (LDT,NW)"],
     "LDT"=>
      ["[in]",
       "         LDT is integer",
       "         The leading dimension of T just as declared in the",
       "         calling subroutine.  NW .LE. LDT"],
     "NV"=>
      ["[in]",
       "         NV is integer",
       "         The number of rows of work array WV available for",
       "         workspace.  NV.GE.NW."],
     "WV"=>
      ["[out]", "         WV is DOUBLE PRECISION array, dimension (LDWV,NW)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer",
       "         The leading dimension of W just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LWORK)",
       "         On exit, WORK(1) is set to an estimate of the optimal value",
       "         of LWORK for the given values of N, NW, KTOP and KBOT."],
     "LWORK"=>
      ["[in]",
       "         LWORK is integer",
       "         The dimension of the work array WORK.  LWORK = 2*NW",
       "         suffices, but greater efficiency may result from larger",
       "         values of LWORK.",
       "         If LWORK = -1, then a workspace query is assumed; DLAQR2",
       "         only estimates the optimal workspace size for the given",
       "         values of N, NW, KTOP and KBOT.  The estimate is returned",
       "         in WORK(1).  No error message related to LWORK is issued",
       "         by XERBLA.  Neither H nor Z are accessed."]}},
 "ztfttr"=>
  {"summary"=>
    ["ZTFTTR copies a triangular matrix A from rectangular full packed",
     "format (TF) to standard full format (TR)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF is in Normal format;",
       "         = 'C':  ARF is in Conjugate-transpose format;"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "ARF"=>
      ["[in]",
       "         ARF is COMPLEX*16 array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "A"=>
      ["[out]",
       "         A is COMPLEX*16 array, dimension ( LDA, N )",
       "         On exit, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cggesx"=>
  {"summary"=>
    ["CGGESX computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, the complex Schur form (S,T),",
     "and, optionally, the left and/or right matrices of Schur vectors (VSL",
     "and VSR).  This gives the generalized Schur factorization",
     "     (A,B) = ( (VSL) S (VSR)**H, (VSL) T (VSR)**H )",
     "where (VSR)**H is the conjugate-transpose of VSR.",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "triangular matrix S and the upper triangular matrix T; computes",
     "a reciprocal condition number for the average of the selected",
     "eigenvalues (RCONDE); and computes a reciprocal condition number for",
     "the right and left deflating subspaces corresponding to the selected",
     "eigenvalues (RCONDV). The leading columns of VSL and VSR then form",
     "an orthonormal basis for the corresponding left and right eigenspaces",
     "(deflating subspaces).",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0 or for both being zero.",
     "A pair of matrices (S,T) is in generalized complex Schur form if T is",
     "upper triangular with non-negative diagonal and S is upper",
     "triangular."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG)."],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is procedure) LOGICAL FUNCTION of two COMPLEX arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         Note that a selected complex eigenvalue may no longer satisfy",
       "         SELCTG(ALPHA(j),BETA(j)) = .TRUE. after ordering, since",
       "         ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned), in this",
       "         case INFO is set to N+3 see INFO below)."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N' : None are computed;",
       "         = 'E' : Computed for average of selected eigenvalues only;",
       "         = 'V' : Computed for selected deflating subspaces only;",
       "         = 'B' : Computed for both.",
       "         If SENSE = 'E', 'V', or 'B', SORT must equal 'S'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX array, dimension (N)",
       "         On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the",
       "         generalized eigenvalues.  ALPHA(j) and BETA(j),j=1,...,N  are",
       "         the diagonals of the complex Schur form (S,T).  BETA(j) will",
       "         be non-negative real.",
       "         Note: the quotients ALPHA(j)/BETA(j) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio alpha/beta.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is COMPLEX array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >=1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is COMPLEX array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is REAL array, dimension ( 2 )",
       "         If SENSE = 'E' or 'B', RCONDE(1) and RCONDE(2) contain the",
       "         reciprocal condition numbers for the average of the selected",
       "         eigenvalues.",
       "         Not referenced if SENSE = 'N' or 'V'."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is REAL array, dimension ( 2 )",
       "         If SENSE = 'V' or 'B', RCONDV(1) and RCONDV(2) contain the",
       "         reciprocal condition number for the selected deflating",
       "         subspaces.",
       "         Not referenced if SENSE = 'N' or 'E'."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N = 0, LWORK >= 1, else if SENSE = 'E', 'V', or 'B',",
       "         LWORK >= MAX(1,2*N,2*SDIM*(N-SDIM)), else",
       "         LWORK >= MAX(1,2*N).  Note that 2*SDIM*(N-SDIM) <= N*N/2.",
       "         Note also that an error is only returned if",
       "         LWORK < MAX(1,2*N), but if SENSE = 'E' or 'V' or 'B' this may",
       "         not be large enough.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the bound on the optimal size of the WORK",
       "         array and the minimum size of the IWORK array, returns these",
       "         values as the first entries of the WORK and IWORK arrays, and",
       "         no error message related to LWORK or LIWORK is issued by",
       "         XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension ( 8*N )",
       "         Real workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SENSE = 'N' or N = 0, LIWORK >= 1, otherwise",
       "         LIWORK >= N+2.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the bound on the optimal size of the",
       "         WORK array and the minimum size of the IWORK array, returns",
       "         these values as the first entries of the WORK and IWORK",
       "         arrays, and no error message related to LWORK or LIWORK is",
       "         issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHA(j) and BETA(j) should be correct for",
       "               j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in CHGEQZ",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in CTGSEN."]}},
 "dorbdb4"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M and",
       "          M-Q <= min(P,M-P,Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is DOUBLE PRECISION array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is DOUBLE PRECISION array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is DOUBLE PRECISION array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is DOUBLE PRECISION array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is DOUBLE PRECISION array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "PHANTOM"=>
      ["[out]",
       "         PHANTOM is DOUBLE PRECISION array, dimension (M)",
       "          The routine computes an M-by-1 column vector Y that is",
       "          orthogonal to the columns of [ X11; X21 ]. PHANTOM(1:P) and",
       "          PHANTOM(P+1:M) contain Householder vectors for Y(1:P) and",
       "          Y(P+1:M), respectively."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ssygs2"=>
  {"summary"=>
    ["SSYGS2 reduces a real symmetric-definite generalized eigenproblem",
     "to standard form.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T *A*L.",
     "B must have been previously factorized as U**T *U or L*L**T by SPOTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T);",
       "         = 2 or 3: compute U*A*U**T or L**T *A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored, and how B has been factorized.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,N)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         as returned by SPOTRF."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "sggbal"=>
  {"summary"=>
    ["SGGBAL balances a pair of general real matrices (A,B).  This",
     "involves, first, permuting A and B by similarity transformations to",
     "isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N",
     "elements on the diagonal; and second, applying a diagonal similarity",
     "transformation to rows and columns ILO to IHI to make the rows",
     "and columns as close in norm as possible. Both steps are optional.",
     "Balancing may reduce the 1-norm of the matrices, and improve the",
     "accuracy of the computed eigenvalues and/or eigenvectors in the",
     "generalized eigenvalue problem A*x = lambda*B*x."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the operations to be performed on A and B:",
       "         = 'N':  none:  simply set ILO = 1, IHI = N, LSCALE(I) = 1.0",
       "                 and RSCALE(I) = 1.0 for i = 1,...,N.",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the input matrix A.",
       "         On exit,  A is overwritten by the balanced matrix.",
       "         If JOB = 'N', A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the input matrix B.",
       "         On exit,  B is overwritten by the balanced matrix.",
       "         If JOB = 'N', B is not referenced."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are set to integers such that on exit",
       "         A(i,j) = 0 and B(i,j) = 0 if i > j and",
       "         j = 1,...,ILO-1 or i = IHI+1,...,N.",
       "         If JOB = 'N' or 'S', ILO = 1 and IHI = N."],
     "LSCALE"=>
      ["[out]",
       "         LSCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the left side of A and B.  If P(j) is the index of the",
       "         row interchanged with row j, and D(j)",
       "         is the scaling factor applied to row j, then",
       "           LSCALE(j) = P(j)    for J = 1,...,ILO-1",
       "                     = D(j)    for J = ILO,...,IHI",
       "                     = P(j)    for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "RSCALE"=>
      ["[out]",
       "         RSCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the right side of A and B.  If P(j) is the index of the",
       "         column interchanged with column j, and D(j)",
       "         is the scaling factor applied to column j, then",
       "           LSCALE(j) = P(j)    for J = 1,...,ILO-1",
       "                     = D(j)    for J = ILO,...,IHI",
       "                     = P(j)    for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (lwork)",
       "         lwork must be at least max(1,6*N) when JOB = 'S' or 'B', and",
       "         at least 1 when JOB = 'N' or 'P'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ssbgvx"=>
  {"summary"=>
    ["SSBGVX computes selected eigenvalues, and optionally, eigenvectors",
     "of a real generalized symmetric-definite banded eigenproblem, of",
     "the form A*x=(lambda)*B*x.  Here A and B are assumed to be symmetric",
     "and banded, and B is also positive definite.  Eigenvalues and",
     "eigenvectors can be selected by specifying either all eigenvalues,",
     "a range of values or a range of indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is REAL array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(ka+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**T*S, as returned by SPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "Q"=>
      ["[out]",
       "         Q is REAL array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the n-by-n matrix used in the reduction of",
       "         A*x = (lambda)*B*x to standard form, i.e. C*x = (lambda)*x,",
       "         and consequently C to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'N',",
       "         LDQ >= 1. If JOBZ = 'V', LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i).  The eigenvectors are",
       "         normalized so Z**T*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (7N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (M)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvalues that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit",
       "         < 0 : if INFO = -i, the i-th argument had an illegal value",
       "         <= N: if INFO = i, then i eigenvectors failed to converge.",
       "                 Their indices are stored in IFAIL.",
       "         > N : SPBSTF returned an error code; i.e.,",
       "               if INFO = N + i, for 1 <= i <= N, then the leading",
       "               minor of order i of B is not positive definite.",
       "               The factorization of B could not be completed and",
       "               no eigenvalues or eigenvectors were computed."]}},
 "sspsvx"=>
  {"summary"=>
    ["SSPSVX uses the diagonal pivoting factorization A = U*D*U**T or",
     "A = L*D*L**T to compute the solution to a real system of linear",
     "equations A * X = B, where A is an N-by-N symmetric matrix stored",
     "in packed format and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "sla_gbrfsx_extended"=>
  {"summary"=>
    ["SLA_GBRFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by SGBRFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "TRANS_TYPE"=>
      ["[in]",
       "         TRANS_TYPE is INTEGER",
       "    Specifies the transposition operation on A.",
       "    The value is defined by ILATRANS(T) where T is a CHARACTER and",
       "    T    = 'N':  No transpose",
       "         = 'T':  Transpose",
       "         = 'C':  Conjugate transpose"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0"],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "    On entry, the N-by-N matrix AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= max(1,N)."],
     "AFB"=>
      ["[in]",
       "         AFB is REAL array, dimension (LDAFB,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by SGBTRF."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AF.  LDAFB >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by SGBTRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by SGBTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is REAL array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by SLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is REAL array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is REAL array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is REAL array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is REAL array, dimension (N)",
       "    Workspace. This can be the same workspace passed for Y_TAIL."],
     "DY"=>
      ["[in]",
       "         DY is REAL array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is REAL array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is REAL",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is REAL",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to SGBTRS had an illegal",
       "            value"]}},
 "csprfs"=>
  {"summary"=>
    ["CSPRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric indefinite",
     "and packed, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n."],
     "AFP"=>
      ["[in]",
       "         AFP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The factored form of the matrix A.  AFP contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**T or",
       "         A = L*D*L**T as computed by CSPTRF, stored as a packed",
       "         triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSPTRF."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by CSPTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlags2"=>
  {"summary"=>
    ["ZLAGS2 computes 2-by-2 unitary matrices U, V and Q, such",
     "that if ( UPPER ) then",
     "          U**H *A*Q = U**H *( A1 A2 )*Q = ( x  0  )",
     "                            ( 0  A3 )     ( x  x  )",
     "and",
     "          V**H*B*Q = V**H *( B1 B2 )*Q = ( x  0  )",
     "                           ( 0  B3 )     ( x  x  )",
     "or if ( .NOT.UPPER ) then",
     "          U**H *A*Q = U**H *( A1 0  )*Q = ( x  x  )",
     "                            ( A2 A3 )     ( 0  x  )",
     "and",
     "          V**H *B*Q = V**H *( B1 0  )*Q = ( x  x  )",
     "                            ( B2 B3 )     ( 0  x  )",
     "where",
     "  U = (   CSU    SNU ), V = (  CSV    SNV ),",
     "      ( -SNU**H  CSU )      ( -SNV**H CSV )",
     "  Q = (   CSQ    SNQ )",
     "      ( -SNQ**H  CSQ )",
     "The rows of the transformed A and B are parallel. Moreover, if the",
     "input 2-by-2 matrix A is not zero, then the transformed (1,1) entry",
     "of A is not zero. If the input matrices A and B are both not zero,",
     "then the transformed (2,2) element of B is not zero, except when the",
     "first rows of input A and B are parallel and the second rows are",
     "zero."],
   "param"=>
    {"UPPER"=>
      ["[in]",
       "         UPPER is LOGICAL",
       "         = .TRUE.: the input matrices A and B are upper triangular.",
       "         = .FALSE.: the input matrices A and B are lower triangular."],
     "A1"=>["[in]", "         A1 is DOUBLE PRECISION"],
     "A2"=>["[in]", "         A2 is COMPLEX*16"],
     "A3"=>
      ["[in]",
       "         A3 is DOUBLE PRECISION",
       "         On entry, A1, A2 and A3 are elements of the input 2-by-2",
       "         upper (lower) triangular matrix A."],
     "B1"=>["[in]", "         B1 is DOUBLE PRECISION"],
     "B2"=>["[in]", "         B2 is COMPLEX*16"],
     "B3"=>
      ["[in]",
       "         B3 is DOUBLE PRECISION",
       "         On entry, B1, B2 and B3 are elements of the input 2-by-2",
       "         upper (lower) triangular matrix B."],
     "CSU"=>["[out]", "         CSU is DOUBLE PRECISION"],
     "SNU"=>
      ["[out]",
       "         SNU is COMPLEX*16",
       "         The desired unitary matrix U."],
     "CSV"=>["[out]", "         CSV is DOUBLE PRECISION"],
     "SNV"=>
      ["[out]",
       "         SNV is COMPLEX*16",
       "         The desired unitary matrix V."],
     "CSQ"=>["[out]", "         CSQ is DOUBLE PRECISION"],
     "SNQ"=>
      ["[out]",
       "         SNQ is COMPLEX*16",
       "         The desired unitary matrix Q."]}},
 "zlansb"=>
  {"summary"=>
    ["ZLANSB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n symmetric band matrix A,  with k super-diagonals.",
     "   ZLANSB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANSB as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         band matrix A is supplied.",
       "         = 'U':  Upper triangular part is supplied",
       "         = 'L':  Lower triangular part is supplied"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANSB is",
       "         set to zero."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of super-diagonals or sub-diagonals of the",
       "         band matrix A.  K >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The upper or lower triangle of the symmetric band matrix A,",
       "         stored in the first K+1 rows of AB.  The j-th column of A is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)   = A(i,j) for j<=i<=min(n,j+k)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= K+1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "dsygst"=>
  {"summary"=>
    ["DSYGST reduces a real symmetric-definite generalized eigenproblem",
     "to standard form.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L.",
     "B must have been previously factorized as U**T*U or L*L**T by DPOTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T);",
       "         = 2 or 3: compute U*A*U**T or L**T*A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored and B is factored as",
       "                 U**T*U;",
       "         = 'L':  Lower triangle of A is stored and B is factored as",
       "                 L*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         as returned by DPOTRF."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlaqhb"=>
  {"summary"=>
    ["ZLAQHB equilibrates a Hermitian band matrix A",
     "using the scaling factors in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H *U or A = L*L**H of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is DOUBLE PRECISION",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "zlaed0"=>
  {"summary"=>
    ["Using the divide and conquer method, ZLAED0 computes all eigenvalues",
     "of a symmetric tridiagonal matrix which is one diagonal block of",
     "those from reducing a dense or band Hermitian matrix and",
     "corresponding eigenvectors of the dense or band matrix."],
   "param"=>
    {"QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the unitary matrix used to reduce",
       "        the full matrix to tridiagonal form.  QSIZ >= N if ICOMPQ = 1."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        On entry, the diagonal elements of the tridiagonal matrix.",
       "        On exit, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "        On entry, the off-diagonal elements of the tridiagonal matrix.",
       "        On exit, E has been destroyed."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,N)",
       "        On entry, Q must contain an QSIZ x N matrix whose columns",
       "        unitarily orthonormal. It is a part of the unitary matrix",
       "        that reduces the full dense Hermitian matrix to a",
       "        (reducible) symmetric tridiagonal matrix."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array,",
       "        the dimension of IWORK must be at least",
       "                     6 + 6*N + 5*N*lg N",
       "                     ( lg( N ) = smallest integer k",
       "                                 such that 2^k >= N )"],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array,",
       "                              dimension (1 + 3*N + 2*N*lg N + 3*N**2)",
       "                       ( lg( N ) = smallest integer k",
       "                                   such that 2^k >= N )"],
     "QSTORE"=>
      ["[out]",
       "         QSTORE is COMPLEX*16 array, dimension (LDQS, N)",
       "        Used to store parts of",
       "        the eigenvector matrix when the updating matrix multiplies",
       "        take place."],
     "LDQS"=>
      ["[in]",
       "         LDQS is INTEGER",
       "        The leading dimension of the array QSTORE.",
       "        LDQS >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The algorithm failed to compute an eigenvalue while",
       "               working on the submatrix lying in rows and columns",
       "               INFO/(N+1) through mod(INFO,N+1)."]}},
 "dtrtrs"=>
  {"summary"=>
    ["DTRTRS solves a triangular system of the form",
     "   A * X = B  or  A**T * X = B,",
     "where A is a triangular matrix of order N, and B is an N-by-NRHS",
     "matrix.  A check is made to verify that A is nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, the i-th diagonal element of A is zero,",
       "              indicating that the matrix is singular and the solutions",
       "              X have not been computed."]}},
 "spoequb"=>
  {"summary"=>
    ["SPOEQUB computes row and column scalings intended to equilibrate a",
     "symmetric positive definite matrix A and reduce its condition number",
     "(with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings.",
     "This routine differs from SPOEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled diagonal entries are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The N-by-N symmetric positive definite matrix whose scaling",
       "         factors are to be computed.  Only the diagonal elements of A",
       "         are referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is REAL",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "dsycon_3"=>
  {"summary"=>
    ["DSYCON_3 estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric matrix A using the factorization",
     "computed by DSYTRF_RK or DSYTRF_BK:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).",
     "This routine uses BLAS3 solver DSYTRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**T)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**T)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by DSYTRF_RK and DSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF_RK or DSYTRF_BK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhetf2_rk"=>
  {"summary"=>
    ["ZHETF2_RK computes the factorization of a complex Hermitian matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the Hermitian block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "zppcon"=>
  {"summary"=>
    ["ZPPCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex Hermitian positive definite packed matrix using",
     "the Cholesky factorization A = U**H*U or A = L*L**H computed by",
     "ZPPTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H, packed columnwise in a linear",
       "         array.  The j-th column of U or L is stored in the array AP",
       "         as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm (or infinity-norm) of the Hermitian matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cpteqr"=>
  {"summary"=>
    ["CPTEQR computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric positive definite tridiagonal matrix by first factoring the",
     "matrix using SPTTRF and then calling CBDSQR to compute the singular",
     "values of the bidiagonal factor.",
     "This routine computes the eigenvalues of the positive definite",
     "tridiagonal matrix to high relative accuracy.  This means that if the",
     "eigenvalues range over many orders of magnitude in size, then the",
     "small eigenvalues and corresponding eigenvectors will be computed",
     "more accurately than, for example, with the standard QR method.",
     "The eigenvectors of a full or band positive definite Hermitian matrix",
     "can also be found if CHETRD, CHPTRD, or CHBTRD has been used to",
     "reduce this matrix to tridiagonal form.  (The reduction to",
     "tridiagonal form, however, may preclude the possibility of obtaining",
     "high relative accuracy in the small eigenvalues of the original",
     "matrix, if these eigenvalues range over many orders of magnitude.)"],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'V':  Compute eigenvectors of original Hermitian",
       "                 matrix also.  Array Z contains the unitary matrix",
       "                 used to reduce the original matrix to tridiagonal",
       "                 form.",
       "         = 'I':  Compute eigenvectors of tridiagonal matrix also."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix.",
       "         On normal exit, D contains the eigenvalues, in descending",
       "         order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the unitary matrix used in the",
       "         reduction to tridiagonal form.",
       "         On exit, if COMPZ = 'V', the orthonormal eigenvectors of the",
       "         original Hermitian matrix;",
       "         if COMPZ = 'I', the orthonormal eigenvectors of the",
       "         tridiagonal matrix.",
       "         If INFO > 0 on exit, Z contains the eigenvectors associated",
       "         with only the stored eigenvalues.",
       "         If  COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         COMPZ = 'V' or 'I', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, and i is:",
       "               <= N  the Cholesky factorization of the matrix could",
       "                     not be performed because the i-th principal minor",
       "                     was not positive definite.",
       "               > N   the SVD algorithm failed to converge;",
       "                     if INFO = N+i, i off-diagonal elements of the",
       "                     bidiagonal factor did not converge to zero."]}},
 "cpptrf"=>
  {"summary"=>
    ["CPPTRF computes the Cholesky factorization of a complex Hermitian",
     "positive definite matrix A stored in packed format.",
     "The factorization has the form",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H*U or A = L*L**H, in the same",
       "         storage format as A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "cla_syamv"=>
  {"summary"=>
    ["CLA_SYAMV  performs the matrix-vector operation",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "n by n symmetric matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is INTEGER",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array A is to be referenced as",
       "          follows:",
       "             UPLO = BLAS_UPPER   Only the upper triangular part of A",
       "                                 is to be referenced.",
       "             UPLO = BLAS_LOWER   Only the lower triangular part of A",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL .",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array of DIMENSION ( LDA, n ).",
       "          Before entry, the leading m by n part of the array A must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, n ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCX ) )",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL .",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCY ) )",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit."]}},
 "cla_gbamv"=>
  {"summary"=>
    ["CLA_GBAMV  performs one of the matrix-vector operations",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "   or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "m by n matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is INTEGER",
       "          On entry, TRANS specifies the operation to be performed as",
       "          follows:",
       "            BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)",
       "            BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "            BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of the matrix A.",
       "          M must be at least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "          The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "          The number of superdiagonals within the band of A.  KU >= 0."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,n)",
       "          Before entry, the leading m by n part of the array AB must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "          On entry, LDAB specifies the first dimension of AB as declared",
       "          in the calling (sub) program. LDAB must be at least",
       "          max( 1, m ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension",
       "          ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit.",
       " Level 2 Blas routine."]}},
 "zgesdd"=>
  {"summary"=>
    ["ZGESDD computes the singular value decomposition (SVD) of a complex",
     "M-by-N matrix A, optionally computing the left and/or right singular",
     "vectors, by using divide-and-conquer method. The SVD is written",
     "     A = U * SIGMA * conjugate-transpose(V)",
     "where SIGMA is an M-by-N matrix which is zero except for its",
     "min(m,n) diagonal elements, U is an M-by-M unitary matrix, and",
     "V is an N-by-N unitary matrix.  The diagonal elements of SIGMA",
     "are the singular values of A; they are real and non-negative, and",
     "are returned in descending order.  The first min(m,n) columns of",
     "U and V are the left and right singular vectors of A.",
     "Note that the routine returns VT = V**H, not V.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'A':  all M columns of U and all N rows of V**H are",
       "                 returned in the arrays U and VT;",
       "         = 'S':  the first min(M,N) columns of U and the first",
       "                 min(M,N) rows of V**H are returned in the arrays U",
       "                 and VT;",
       "         = 'O':  If M >= N, the first N columns of U are overwritten",
       "                 in the array A and all rows of V**H are returned in",
       "                 the array VT;",
       "                 otherwise, all columns of U are returned in the",
       "                 array U and the first M rows of V**H are overwritten",
       "                 in the array A;",
       "         = 'N':  no columns of U or rows of V**H are computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if JOBZ = 'O',  A is overwritten with the first N columns",
       "                         of U (the left singular vectors, stored",
       "                         columnwise) if M >= N;",
       "                         A is overwritten with the first M rows",
       "                         of V**H (the right singular vectors, stored",
       "                         rowwise) otherwise.",
       "         if JOBZ .ne. 'O', the contents of A are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is COMPLEX*16 array, dimension (LDU,UCOL)",
       "         UCOL = M if JOBZ = 'A' or JOBZ = 'O' and M < N;",
       "         UCOL = min(M,N) if JOBZ = 'S'.",
       "         If JOBZ = 'A' or JOBZ = 'O' and M < N, U contains the M-by-M",
       "         unitary matrix U;",
       "         if JOBZ = 'S', U contains the first min(M,N) columns of U",
       "         (the left singular vectors, stored columnwise);",
       "         if JOBZ = 'O' and M >= N, or JOBZ = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1;",
       "         if JOBZ = 'S' or 'A' or JOBZ = 'O' and M < N, LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is COMPLEX*16 array, dimension (LDVT,N)",
       "         If JOBZ = 'A' or JOBZ = 'O' and M >= N, VT contains the",
       "         N-by-N unitary matrix V**H;",
       "         if JOBZ = 'S', VT contains the first min(M,N) rows of",
       "         V**H (the right singular vectors, stored rowwise);",
       "         if JOBZ = 'O' and M < N, or JOBZ = 'N', VT is not referenced."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1;",
       "         if JOBZ = 'A' or JOBZ = 'O' and M >= N, LDVT >= N;",
       "         if JOBZ = 'S', LDVT >= min(M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= 1.",
       "         If LWORK = -1, a workspace query is assumed.  The optimal",
       "         size for the WORK array is calculated and stored in WORK(1),",
       "         and no other work except argument checking is performed.",
       "         Let mx = max(M,N) and mn = min(M,N).",
       "         If JOBZ = 'N', LWORK >= 2*mn + mx.",
       "         If JOBZ = 'O', LWORK >= 2*mn*mn + 2*mn + mx.",
       "         If JOBZ = 'S', LWORK >=   mn*mn + 3*mn.",
       "         If JOBZ = 'A', LWORK >=   mn*mn + 2*mn + mx.",
       "         These are not tight minimums in all cases; see comments inside code.",
       "         For good performance, LWORK should generally be larger;",
       "         a query is recommended."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))",
       "         Let mx = max(M,N) and mn = min(M,N).",
       "         If JOBZ = 'N',    LRWORK >= 5*mn (LAPACK <= 3.6 needs 7*mn);",
       "         else if mx >> mn, LRWORK >= 5*mn*mn + 5*mn;",
       "         else              LRWORK >= max( 5*mn*mn + 5*mn,",
       "                                          2*mx*mn + 2*mn*mn + mn )."],
     "IWORK"=>
      ["[out]", "         IWORK is INTEGER array, dimension (8*min(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The updating process of DBDSDC did not converge."]}},
 "slatdf"=>
  {"summary"=>
    ["SLATDF uses the LU factorization of the n-by-n matrix Z computed by",
     "SGETC2 and computes a contribution to the reciprocal Dif-estimate",
     "by solving Z * x = b for x, and choosing the r.h.s. b such that",
     "the norm of x is as large as possible. On entry RHS = b holds the",
     "contribution from earlier solved sub-systems, and on return RHS = x.",
     "The factorization of Z returned by SGETC2 has the form Z = P*L*U*Q,",
     "where P and Q are permutation matrices. L is lower triangular with",
     "unit diagonal elements and U is upper triangular."],
   "param"=>
    {"IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         IJOB = 2: First compute an approximative null-vector e",
       "             of Z using SGECON, e is normalized and solve for",
       "             Zx = +-e - f with the sign giving the greater value",
       "             of 2-norm(x). About 5 times as expensive as Default.",
       "         IJOB .ne. 2: Local look ahead strategy where all entries of",
       "             the r.h.s. b is chosen as either +1 or -1 (Default)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Z."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         On entry, the LU part of the factorization of the n-by-n",
       "         matrix Z computed by SGETC2:  Z = P * L * U * Q"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDA >= max(1, N)."],
     "RHS"=>
      ["[in,out]",
       "         RHS is REAL array, dimension N.",
       "         On entry, RHS contains contributions from other subsystems.",
       "         On exit, RHS contains the solution of the subsystem with",
       "         entries acoording to the value of IJOB (see above)."],
     "RDSUM"=>
      ["[in,out]",
       "         RDSUM is REAL",
       "         On entry, the sum of squares of computed contributions to",
       "         the Dif-estimate under computation by STGSYL, where the",
       "         scaling factor RDSCAL (see below) has been factored out.",
       "         On exit, the corresponding sum of squares updated with the",
       "         contributions from the current sub-system.",
       "         If TRANS = 'T' RDSUM is not touched.",
       "         NOTE: RDSUM only makes sense when STGSY2 is called by STGSYL."],
     "RDSCAL"=>
      ["[in,out]",
       "         RDSCAL is REAL",
       "         On entry, scaling factor used to prevent overflow in RDSUM.",
       "         On exit, RDSCAL is updated w.r.t. the current contributions",
       "         in RDSUM.",
       "         If TRANS = 'T', RDSCAL is not touched.",
       "         NOTE: RDSCAL only makes sense when STGSY2 is called by",
       "               STGSYL."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[in]",
       "         JPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."]}},
 "dla_gbamv"=>
  {"summary"=>
    ["DLA_GBAMV  performs one of the matrix-vector operations",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "   or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "m by n matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is INTEGER",
       "          On entry, TRANS specifies the operation to be performed as",
       "          follows:",
       "            BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)",
       "            BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "            BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of the matrix A.",
       "          M must be at least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "          The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "          The number of superdiagonals within the band of A.  KU >= 0."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array of DIMENSION ( LDAB, n )",
       "          Before entry, the leading m by n part of the array AB must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "          On entry, LDA specifies the first dimension of AB as declared",
       "          in the calling (sub) program. LDAB must be at least",
       "          max( 1, m ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is DOUBLE PRECISION array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension",
       "          ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit.",
       " Level 2 Blas routine."]}},
 "dsyevr_2stage"=>
  {"summary"=>
    ["DSYEVR_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  Eigenvalues and eigenvectors can be",
     "selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues.",
     "DSYEVR_2STAGE first reduces the matrix A to tridiagonal form T with a call",
     "to DSYTRD.  Then, whenever possible, DSYEVR_2STAGE calls DSTEMR to compute",
     "the eigenspectrum using Relatively Robust Representations.  DSTEMR",
     "computes eigenvalues by the dqds algorithm, while orthogonal",
     "eigenvectors are computed from various \"good\" L D L^T representations",
     "(also known as Relatively Robust Representations). Gram-Schmidt",
     "orthogonalization is avoided as far as possible. More specifically,",
     "the various steps of the algorithm are as follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "The desired accuracy of the output can be specified by the input",
     "parameter ABSTOL.",
     "For more details, see DSTEMR's documentation and:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Note 1 : DSYEVR_2STAGE calls DSTEMR when the full spectrum is requested",
     "on machines which conform to the ieee-754 floating point standard.",
     "DSYEVR_2STAGE calls DSTEBZ and SSTEIN on non-ieee machines and",
     "when partial spectrum requests are made.",
     "Normal execution of DSTEMR may create NaNs and infinities and",
     "hence may abort due to a floating point exception in environments",
     "which do not handle NaNs and infinities in the ieee standard default",
     "manner."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found.",
       "         For RANGE = 'V' or 'I' and IU - IL < N - 1, DSTEBZ and",
       "         DSTEIN are called"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3.",
       "         If high relative accuracy is important, set ABSTOL to",
       "         DLAMCH( 'Safe minimum' ).  Doing so will guarantee that",
       "         eigenvalues are computed to high relative accuracy when",
       "         possible in future releases.  The current code does not",
       "         make any guarantees about high relative accuracy, but",
       "         future releases will. See J. Barlow and J. Demmel,",
       "         \"Computing Accurate Eigensystems of Scaled Diagonally",
       "         Dominant Matrices\", LAPACK Working Note #7, for a discussion",
       "         of which matrices define their eigenvalues to high relative",
       "         accuracy."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used.",
       "         Supplying N columns is always safe."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is an output of DSTEMR (tridiagonal",
       "         matrix). The support of the eigenvectors of A is typically ",
       "         1:N because of the orthogonal transformations applied by DORMTR.",
       "         Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1"],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, 26*N, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + 5*N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + 5*N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  Internal error"]}},
 "slasq4"=>
  {"summary"=>
    ["SLASQ4 computes an approximation TAU to the smallest eigenvalue",
     "using values of d from the previous transform."],
   "param"=>
    {"I0"=>["[in]", "         I0 is INTEGER", "       First index."],
     "N0"=>["[in]", "         N0 is INTEGER", "       Last index."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension ( 4*N0 )",
       "       Z holds the qd array."],
     "PP"=>
      ["[in]",
       "         PP is INTEGER",
       "       PP=0 for ping, PP=1 for pong."],
     "N0IN"=>
      ["[in]",
       "         N0IN is INTEGER",
       "       The value of N0 at start of EIGTEST."],
     "DMIN"=>["[in]", "         DMIN is REAL", "       Minimum value of d."],
     "DMIN1"=>
      ["[in]",
       "         DMIN1 is REAL",
       "       Minimum value of d, excluding D( N0 )."],
     "DMIN2"=>
      ["[in]",
       "         DMIN2 is REAL",
       "       Minimum value of d, excluding D( N0 ) and D( N0-1 )."],
     "DN"=>["[in]", "         DN is REAL", "       d(N)"],
     "DN1"=>["[in]", "         DN1 is REAL", "       d(N-1)"],
     "DN2"=>["[in]", "         DN2 is REAL", "       d(N-2)"],
     "TAU"=>["[out]", "         TAU is REAL", "       This is the shift."],
     "TTYPE"=>["[out]", "         TTYPE is INTEGER", "       Shift type."],
     "G"=>
      ["[in,out]",
       "         G is REAL",
       "       G is passed as an argument in order to save its value between",
       "       calls to SLASQ4."]}},
 "dlacpy"=>
  {"summary"=>
    ["DLACPY copies all or part of a two-dimensional matrix A to another",
     "matrix B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the part of the matrix A to be copied to B.",
       "         = 'U':      Upper triangular part",
       "         = 'L':      Lower triangular part",
       "         Otherwise:  All of the matrix A"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The m by n matrix A.  If UPLO = 'U', only the upper triangle",
       "         or trapezoid is accessed; if UPLO = 'L', only the lower",
       "         triangle or trapezoid is accessed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On exit, B = A in the locations specified by UPLO."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."]}},
 "zbdsqr"=>
  {"summary"=>
    ["ZBDSQR computes the singular values and, optionally, the right and/or",
     "left singular vectors from the singular value decomposition (SVD) of",
     "a real N-by-N (upper or lower) bidiagonal matrix B using the implicit",
     "zero-shift QR algorithm.  The SVD of B has the form",
     "   B = Q * S * P**H",
     "where S is the diagonal matrix of singular values, Q is an orthogonal",
     "matrix of left singular vectors, and P is an orthogonal matrix of",
     "right singular vectors.  If left singular vectors are requested, this",
     "subroutine actually returns U*Q instead of Q, and, if right singular",
     "vectors are requested, this subroutine returns P**H*VT instead of",
     "P**H, for given complex input matrices U and VT.  When U and VT are",
     "the unitary matrices that reduce a general matrix A to bidiagonal",
     "form: A = U*B*VT, as computed by ZGEBRD, then",
     "   A = (U*Q) * S * (P**H*VT)",
     "is the SVD of A.  Optionally, the subroutine may also compute Q**H*C",
     "for a given complex input matrix C.",
     "See \"Computing  Small Singular Values of Bidiagonal Matrices With",
     "Guaranteed High Relative Accuracy,\" by J. Demmel and W. Kahan,",
     "LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11,",
     "no. 5, pp. 873-912, Sept 1990) and",
     "\"Accurate singular values and differential qd algorithms,\" by",
     "B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics",
     "Department, University of California at Berkeley, July 1992",
     "for a detailed description of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  B is upper bidiagonal;",
       "         = 'L':  B is lower bidiagonal."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix B.  N >= 0."],
     "NCVT"=>
      ["[in]",
       "         NCVT is INTEGER",
       "         The number of columns of the matrix VT. NCVT >= 0."],
     "NRU"=>
      ["[in]",
       "         NRU is INTEGER",
       "         The number of rows of the matrix U. NRU >= 0."],
     "NCC"=>
      ["[in]",
       "         NCC is INTEGER",
       "         The number of columns of the matrix C. NCC >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the bidiagonal matrix B.",
       "         On exit, if INFO=0, the singular values of B in decreasing",
       "         order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the N-1 offdiagonal elements of the bidiagonal",
       "         matrix B.",
       "         On exit, if INFO = 0, E is destroyed; if INFO > 0, D and E",
       "         will contain the diagonal and superdiagonal elements of a",
       "         bidiagonal matrix orthogonally equivalent to the one given",
       "         as input."],
     "VT"=>
      ["[in,out]",
       "         VT is COMPLEX*16 array, dimension (LDVT, NCVT)",
       "         On entry, an N-by-NCVT matrix VT.",
       "         On exit, VT is overwritten by P**H * VT.",
       "         Not referenced if NCVT = 0."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.",
       "         LDVT >= max(1,N) if NCVT > 0; LDVT >= 1 if NCVT = 0."],
     "U"=>
      ["[in,out]",
       "         U is COMPLEX*16 array, dimension (LDU, N)",
       "         On entry, an NRU-by-N matrix U.",
       "         On exit, U is overwritten by U * Q.",
       "         Not referenced if NRU = 0."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= max(1,NRU)."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC, NCC)",
       "         On entry, an N-by-NCC matrix C.",
       "         On exit, C is overwritten by Q**H * C.",
       "         Not referenced if NCC = 0."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.",
       "         LDC >= max(1,N) if NCC > 0; LDC >=1 if NCC = 0."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  If INFO = -i, the i-th argument had an illegal value",
       "         > 0:  the algorithm did not converge; D and E contain the",
       "               elements of a bidiagonal matrix which is orthogonally",
       "               similar to the input matrix B;  if INFO = i, i",
       "               elements of E have not converged to zero."]}},
 "sgebd2"=>
  {"summary"=>
    ["SGEBD2 reduces a real general m by n matrix A to upper or lower",
     "bidiagonal form B by an orthogonal transformation: Q**T * A * P = B.",
     "If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the m by n general matrix to be reduced.",
       "         On exit,",
       "         if m >= n, the diagonal and the first superdiagonal are",
       "           overwritten with the upper bidiagonal matrix B; the",
       "           elements below the diagonal, with the array TAUQ, represent",
       "           the orthogonal matrix Q as a product of elementary",
       "           reflectors, and the elements above the first superdiagonal,",
       "           with the array TAUP, represent the orthogonal matrix P as",
       "           a product of elementary reflectors;",
       "         if m < n, the diagonal and the first subdiagonal are",
       "           overwritten with the lower bidiagonal matrix B; the",
       "           elements below the first subdiagonal, with the array TAUQ,",
       "           represent the orthogonal matrix Q as a product of",
       "           elementary reflectors, and the elements above the diagonal,",
       "           with the array TAUP, represent the orthogonal matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (min(M,N)-1)",
       "         The off-diagonal elements of the bidiagonal matrix B:",
       "         if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;",
       "         if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is REAL array dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix P. See Further Details."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (max(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit.",
       "         < 0: if INFO = -i, the i-th argument had an illegal value."]}},
 "dlacon"=>
  {"summary"=>
    ["DLACON estimates the 1-norm of a square, real matrix A.",
     "Reverse communication is used for evaluating matrix-vector products."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The order of the matrix.  N >= 1."],
     "V"=>
      ["[out]",
       "         V is DOUBLE PRECISION array, dimension (N)",
       "        On the final return, V = A*W,  where  EST = norm(V)/norm(W)",
       "        (W is not returned)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (N)",
       "        On an intermediate return, X should be overwritten by",
       "              A * X,   if KASE=1,",
       "              A**T * X,  if KASE=2,",
       "        and DLACON must be re-called with all the other parameters",
       "        unchanged."],
     "ISGN"=>["[out]", "         ISGN is INTEGER array, dimension (N)"],
     "EST"=>
      ["[in,out]",
       "         EST is DOUBLE PRECISION",
       "        On entry with KASE = 1 or 2 and JUMP = 3, EST should be",
       "        unchanged from the previous call to DLACON.",
       "        On exit, EST is an estimate (a lower bound) for norm(A)."],
     "KASE"=>
      ["[in,out]",
       "         KASE is INTEGER",
       "        On the initial call to DLACON, KASE should be 0.",
       "        On an intermediate return, KASE will be 1 or 2, indicating",
       "        whether X should be overwritten by A * X  or A**T * X.",
       "        On the final return from DLACON, KASE will again be 0."]}},
 "strtri"=>
  {"summary"=>
    ["STRTRI computes the inverse of a real upper or lower triangular",
     "matrix A.",
     "This is the Level 3 BLAS version of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced.  If DIAG = 'U', the",
       "         diagonal elements of A are also not referenced and are",
       "         assumed to be 1.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, A(i,i) is exactly zero.  The triangular",
       "              matrix is singular and its inverse can not be computed."]}},
 "dorbdb"=>
  {"summary"=>
    ["DORBDB simultaneously bidiagonalizes the blocks of an M-by-M",
     "partitioned orthogonal matrix X:",
     "                                [ B11 | B12 0  0 ]",
     "    [ X11 | X12 ]   [ P1 |    ] [  0  |  0 -I  0 ] [ Q1 |    ]**T",
     "X = [-----------] = [---------] [----------------] [---------]   .",
     "    [ X21 | X22 ]   [    | P2 ] [ B21 | B22 0  0 ] [    | Q2 ]",
     "                                [  0  |  0  0  I ]",
     "X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is",
     "not the case, then X must be transposed and/or permuted. This can be",
     "done in constant time using the TRANS and SIGNS options. See DORCSD",
     "for details.)",
     "The orthogonal matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by-",
     "(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are",
     "represented implicitly by Householder vectors.",
     "B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented",
     "implicitly by angles THETA, PHI."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "SIGNS"=>
      ["[in]",
       "         SIGNS is CHARACTER",
       "         = 'O':      The lower-left block is made nonpositive (the",
       "                     \"other\" convention);",
       "         otherwise:  The upper-right block is made nonpositive (the",
       "                     \"default\" convention)."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11 and X12. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <=",
       "         MIN(P,M-P,M-Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is DOUBLE PRECISION array, dimension (LDX11,Q)",
       "         On entry, the top-left block of the orthogonal matrix to be",
       "         reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the columns of tril(X11) specify reflectors for P1,",
       "            the rows of triu(X11,1) specify reflectors for Q1;",
       "         else TRANS = 'T', and",
       "            the rows of triu(X11) specify reflectors for P1,",
       "            the columns of tril(X11,-1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. If TRANS = 'N', then LDX11 >=",
       "         P; else LDX11 >= Q."],
     "X12"=>
      ["[in,out]",
       "         X12 is DOUBLE PRECISION array, dimension (LDX12,M-Q)",
       "         On entry, the top-right block of the orthogonal matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the rows of triu(X12) specify the first P reflectors for",
       "            Q2;",
       "         else TRANS = 'T', and",
       "            the columns of tril(X12) specify the first P reflectors",
       "            for Q2."],
     "LDX12"=>
      ["[in]",
       "         LDX12 is INTEGER",
       "         The leading dimension of X12. If TRANS = 'N', then LDX12 >=",
       "         P; else LDX11 >= M-Q."],
     "X21"=>
      ["[in,out]",
       "         X21 is DOUBLE PRECISION array, dimension (LDX21,Q)",
       "         On entry, the bottom-left block of the orthogonal matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the columns of tril(X21) specify reflectors for P2;",
       "         else TRANS = 'T', and",
       "            the rows of triu(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "         The leading dimension of X21. If TRANS = 'N', then LDX21 >=",
       "         M-P; else LDX21 >= Q."],
     "X22"=>
      ["[in,out]",
       "         X22 is DOUBLE PRECISION array, dimension (LDX22,M-Q)",
       "         On entry, the bottom-right block of the orthogonal matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the rows of triu(X22(Q+1:M-P,P+1:M-Q)) specify the last",
       "            M-P-Q reflectors for Q2,",
       "         else TRANS = 'T', and",
       "            the columns of tril(X22(P+1:M-Q,Q+1:M-P)) specify the last",
       "            M-P-Q reflectors for P2."],
     "LDX22"=>
      ["[in]",
       "         LDX22 is INTEGER",
       "         The leading dimension of X22. If TRANS = 'N', then LDX22 >=",
       "         M-P; else LDX22 >= M-Q."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "         The entries of the bidiagonal blocks B11, B12, B21, B22 can",
       "         be computed from the angles THETA and PHI. See Further",
       "         Details."],
     "PHI"=>
      ["[out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "         The entries of the bidiagonal blocks B11, B12, B21, B22 can",
       "         be computed from the angles THETA and PHI. See Further",
       "         Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is DOUBLE PRECISION array, dimension (P)",
       "         The scalar factors of the elementary reflectors that define",
       "         P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is DOUBLE PRECISION array, dimension (M-P)",
       "         The scalar factors of the elementary reflectors that define",
       "         P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is DOUBLE PRECISION array, dimension (Q)",
       "         The scalar factors of the elementary reflectors that define",
       "         Q1."],
     "TAUQ2"=>
      ["[out]",
       "         TAUQ2 is DOUBLE PRECISION array, dimension (M-Q)",
       "         The scalar factors of the elementary reflectors that define",
       "         Q2."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= M-Q.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slatrs"=>
  {"summary"=>
    ["SLATRS solves one of the triangular systems",
     "   A *x = s*b  or  A**T*x = s*b",
     "with scaling to prevent overflow.  Here A is an upper or lower",
     "triangular matrix, A**T denotes the transpose of A, x and b are",
     "n-element vectors, and s is a scaling factor, usually less than",
     "or equal to 1, chosen so that the components of x will be less than",
     "the overflow threshold.  If the unscaled problem will not cause",
     "overflow, the Level 2 BLAS routine STRSV is called.  If the matrix A",
     "is singular (A(j,j) = 0 for some j), then s is set to 0 and a",
     "non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b  (No transpose)",
       "         = 'T':  Solve A**T* x = s*b  (Transpose)",
       "         = 'C':  Solve A**T* x = s*b  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading n by n",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading n by n lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max (1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b  or  A**T* x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is REAL array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "slanv2"=>
  {"summary"=>
    ["SLANV2 computes the Schur factorization of a real 2-by-2 nonsymmetric",
     "matrix in standard form:",
     "     [ A  B ] = [ CS -SN ] [ AA  BB ] [ CS  SN ]",
     "     [ C  D ]   [ SN  CS ] [ CC  DD ] [-SN  CS ]",
     "where either",
     "1) CC = 0 so that AA and DD are real eigenvalues of the matrix, or",
     "2) AA = DD and BB*CC < 0, so that AA + or - sqrt(BB*CC) are complex",
     "conjugate eigenvalues."],
   "param"=>
    {"A"=>["[in,out]", "         A is REAL"],
     "B"=>["[in,out]", "         B is REAL"],
     "C"=>["[in,out]", "         C is REAL"],
     "D"=>
      ["[in,out]",
       "         D is REAL",
       "         On entry, the elements of the input matrix.",
       "         On exit, they are overwritten by the elements of the",
       "         standardised Schur form."],
     "RT1R"=>["[out]", "         RT1R is REAL"],
     "RT1I"=>["[out]", "         RT1I is REAL"],
     "RT2R"=>["[out]", "         RT2R is REAL"],
     "RT2I"=>
      ["[out]",
       "         RT2I is REAL",
       "         The real and imaginary parts of the eigenvalues. If the",
       "         eigenvalues are a complex conjugate pair, RT1I > 0."],
     "CS"=>["[out]", "         CS is REAL"],
     "SN"=>
      ["[out]",
       "         SN is REAL",
       "         Parameters of the rotation matrix."]}},
 "dgelsd"=>
  {"summary"=>
    ["DGELSD computes the minimum-norm solution to a real linear least",
     "squares problem:",
     "    minimize 2-norm(| b - A*x |)",
     "using the singular value decomposition (SVD) of A. A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X.",
     "The problem is solved in three steps:",
     "(1) Reduce the coefficient matrix A to bidiagonal form with",
     "    Householder transformations, reducing the original problem",
     "    into a \"bidiagonal least squares problem\" (BLS)",
     "(2) Solve the BLS using a divide and conquer approach.",
     "(3) Apply back all the Householder transformations to solve",
     "    the original least squares problem.",
     "The effective rank of A is determined by treating as zero those",
     "singular values which are less than RCOND times the largest singular",
     "value.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of A. N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A has been destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, B is overwritten by the N-by-NRHS solution",
       "         matrix X.  If m >= n and RANK = n, the residual",
       "         sum-of-squares for the solution in the i-th column is given",
       "         by the sum of squares of elements n+1:m in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,max(M,N))."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The singular values of A in decreasing order.",
       "         The condition number of A in the 2-norm = S(1)/S(min(m,n))."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "         RCOND is used to determine the effective rank of A.",
       "         Singular values S(i) <= RCOND*S(1) are treated as zero.",
       "         If RCOND < 0, machine precision is used instead."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the number of singular values",
       "         which are greater than RCOND*S(1)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK must be at least 1.",
       "         The exact minimum amount of workspace needed depends on M,",
       "         N and NRHS. As long as LWORK is at least",
       "             12*N + 2*N*SMLSIZ + 8*N*NLVL + N*NRHS + (SMLSIZ+1)**2,",
       "         if M is greater than or equal to N or",
       "             12*M + 2*M*SMLSIZ + 8*M*NLVL + M*NRHS + (SMLSIZ+1)**2,",
       "         if M is less than N, the code will execute correctly.",
       "         SMLSIZ is returned by ILAENV and is equal to the maximum",
       "         size of the subproblems at the bottom of the computation",
       "         tree (usually about 25), and",
       "            NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 )",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         LIWORK >= max(1, 3 * MINMN * NLVL + 11 * MINMN),",
       "         where MINMN = MIN( M,N ).",
       "         On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  the algorithm for computing the SVD failed to converge;",
       "               if INFO = i, i off-diagonal elements of an intermediate",
       "               bidiagonal form did not converge to zero."]}},
 "ssptrf"=>
  {"summary"=>
    ["SSPTRF computes the factorization of a real symmetric matrix A stored",
     "in packed format using the Bunch-Kaufman diagonal pivoting method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L, stored as a packed triangular",
       "         matrix overwriting A (see below for further details)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "dlaed4"=>
  {"summary"=>
    ["This subroutine computes the I-th updated eigenvalue of a symmetric",
     "rank-one modification to a diagonal matrix whose elements are",
     "given in the array d, and that",
     "           D(i) < D(j)  for  i < j",
     "and that RHO > 0.  This is arranged by the calling routine, and is",
     "no loss in generality.  The rank-one modified system is thus",
     "           diag( D )  +  RHO * Z * Z_transpose.",
     "where we assume the Euclidean norm of Z is 1.",
     "The method consists of approximating the rational functions in the",
     "secular equation by simpler interpolating rational functions."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "        The length of all arrays."],
     "I"=>
      ["[in]",
       "         I is INTEGER",
       "        The index of the eigenvalue to be computed.  1 <= I <= N."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        The original eigenvalues.  It is assumed that they are in",
       "        order, D(I) < D(J)  for I < J."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension (N)",
       "        The components of the updating vector."],
     "DELTA"=>
      ["[out]",
       "         DELTA is DOUBLE PRECISION array, dimension (N)",
       "        If N .GT. 2, DELTA contains (D(j) - lambda_I) in its  j-th",
       "        component.  If N = 1, then DELTA(1) = 1. If N = 2, see DLAED5",
       "        for detail. The vector DELTA contains the information necessary",
       "        to construct the eigenvectors by DLAED3 and DLAED9."],
     "RHO"=>
      ["[in]",
       "         RHO is DOUBLE PRECISION",
       "        The scalar in the symmetric updating formula."],
     "DLAM"=>
      ["[out]",
       "         DLAM is DOUBLE PRECISION",
       "        The computed lambda_I, the I-th updated eigenvalue."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit",
       "        > 0:  if INFO = 1, the updating process failed."]}},
 "zlasyf_rook"=>
  {"summary"=>
    ["ZLASYF_ROOK computes a partial factorization of a complex symmetric",
     "matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal",
     "pivoting method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**T L21**T )  if UPLO = 'L'",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "ZLASYF_ROOK is an auxiliary routine called by ZSYTRF_ROOK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "W"=>["[out]", "         W is COMPLEX*16 array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "zhpgvd"=>
  {"summary"=>
    ["ZHPGVD computes all the eigenvalues and, optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be Hermitian, stored in packed format, and B is also",
     "positive definite.",
     "If eigenvectors are desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H, in the same storage",
       "         format as B."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors.  The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the required LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LWORK >= N.",
       "         If JOBZ = 'V' and N > 1, LWORK >= 2*N.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the required sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the required LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK.",
       "         If N <= 1,               LRWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LRWORK >= N.",
       "         If JOBZ = 'V' and N > 1, LRWORK >= 1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the required LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK >= 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  ZPPTRF or ZHPEVD returned an error code:",
       "            <= N:  if INFO = i, ZHPEVD failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not convergeto zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= n, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "cgelqt"=>
  {"summary"=>
    ["CGELQT computes a blocked LQ factorization of a complex M-by-N matrix A",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.  MIN(M,N) >= MB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the M-by-MIN(M,N) lower trapezoidal matrix L (L is",
       "         lower triangular if M <= N); the elements above the diagonal",
       "         are the rows of V."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,MIN(M,N))",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (MB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ssyconvf"=>
  {"summary"=>
    ["If parameter WAY = 'C':",
     "SSYCONVF converts the factorization output format used in",
     "SSYTRF provided on entry in parameter A into the factorization",
     "output format used in SSYTRF_RK (or SSYTRF_BK) that is stored",
     "on exit in parameters A and E. It also coverts in place details of",
     "the intechanges stored in IPIV from the format used in SSYTRF into",
     "the format used in SSYTRF_RK (or SSYTRF_BK).",
     "If parameter WAY = 'R':",
     "SSYCONVF performs the conversion in reverse direction, i.e.",
     "converts the factorization output format used in SSYTRF_RK",
     "(or SSYTRF_BK) provided on entry in parametes A and E into",
     "the factorization output format used in SSYTRF that is stored",
     "on exit in parameter A. It also coverts in place details of",
     "the intechanges stored in IPIV from the format used in SSYTRF_RK",
     "(or SSYTRF_BK) into the format used in SSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix A.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         1) If WAY ='C':",
       "         On entry, contains factorization details in format used in",
       "         SSYTRF:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         SSYTRF_RK or SSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         2) If WAY = 'R':",
       "         On entry, contains factorization details in format used in",
       "         SSYTRF_RK or SSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         SSYTRF:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, just a workspace.",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         2) If WAY = 'R':",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not referenced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         On exit, is not changed"],
     "IPIV"=>
      ["[in,out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, details of the interchanges and the block",
       "         structure of D in the format used in SSYTRF.",
       "         On exit, details of the interchanges and the block",
       "         structure of D in the format used in SSYTRF_RK",
       "         ( or SSYTRF_BK).",
       "         1) If WAY ='R':",
       "         On entry, details of the interchanges and the block",
       "         structure of D in the format used in SSYTRF_RK",
       "         ( or SSYTRF_BK).",
       "         On exit, details of the interchanges and the block",
       "         structure of D in the format used in SSYTRF."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgelsy"=>
  {"summary"=>
    ["DGELSY computes the minimum-norm solution to a real linear least",
     "squares problem:",
     "    minimize || A * X - B ||",
     "using a complete orthogonal factorization of A.  A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X.",
     "The routine first computes a QR factorization with column pivoting:",
     "    A * P = Q * [ R11 R12 ]",
     "                [  0  R22 ]",
     "with R11 defined as the largest leading submatrix whose estimated",
     "condition number is less than 1/RCOND.  The order of R11, RANK,",
     "is the effective rank of A.",
     "Then, R22 is considered to be negligible, and R12 is annihilated",
     "by orthogonal transformations from the right, arriving at the",
     "complete orthogonal factorization:",
     "   A * P = Q * [ T11 0 ] * Z",
     "               [  0  0 ]",
     "The minimum-norm solution is then",
     "   X = P * Z**T [ inv(T11)*Q1**T*B ]",
     "                [        0         ]",
     "where Q1 consists of the first RANK columns of Q.",
     "This routine is basically identical to the original xGELSX except",
     "three differences:",
     "  o The call to the subroutine xGEQPF has been substituted by the",
     "    the call to the subroutine xGEQP3. This subroutine is a Blas-3",
     "    version of the QR factorization with column pivoting.",
     "  o Matrix B (the right hand side) is updated with Blas-3.",
     "  o The permutation of matrix B (the right hand side) is faster and",
     "    more simple."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A has been overwritten by details of its",
       "         complete orthogonal factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,M,N)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(i) .ne. 0, the i-th column of A is permuted",
       "         to the front of AP, otherwise column i is a free column.",
       "         On exit, if JPVT(i) = k, then the i-th column of AP",
       "         was the k-th column of A."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "         RCOND is used to determine the effective rank of A, which",
       "         is defined as the order of the largest leading triangular",
       "         submatrix R11 in the QR factorization with pivoting of A,",
       "         whose estimated condition number < 1/RCOND."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the order of the submatrix",
       "         R11.  This is the same as the order of the submatrix T11",
       "         in the complete orthogonal factorization of A."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         The unblocked strategy requires that:",
       "            LWORK >= MAX( MN+3*N+1, 2*MN+NRHS ),",
       "         where MN = min( M, N ).",
       "         The block algorithm requires that:",
       "            LWORK >= MAX( MN+2*N+NB*(N+1), 2*MN+NB*NRHS ),",
       "         where NB is an upper bound on the blocksize returned",
       "         by ILAENV for the routines DGEQP3, DTZRZF, STZRQF, DORMQR,",
       "         and DORMRZ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -i, the i-th argument had an illegal value."]}},
 "sopgtr"=>
  {"summary"=>
    ["SOPGTR generates a real orthogonal matrix Q which is defined as the",
     "product of n-1 elementary reflectors H(i) of order n, as returned by",
     "SSPTRD using packed storage:",
     "if UPLO = 'U', Q = H(n-1) . . . H(2) H(1),",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(n-1)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangular packed storage used in previous",
       "                call to SSPTRD;",
       "         = 'L': Lower triangular packed storage used in previous",
       "                call to SSPTRD."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The vectors which define the elementary reflectors, as",
       "         returned by SSPTRD."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SSPTRD."],
     "Q"=>
      ["[out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "         The N-by-N orthogonal matrix Q."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N-1)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlansf"=>
  {"summary"=>
    ["DLANSF returns the value of the one norm, or the Frobenius norm, or",
     "the infinity norm, or the element of largest absolute value of a",
     "real symmetric matrix A in RFP format.",
     "   DLANSF = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a  matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANSF as described",
       "         above."],
     "TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         Specifies whether the RFP format of A is normal or",
       "         transposed format.",
       "         = 'N':  RFP format is Normal;",
       "         = 'T':  RFP format is Transpose."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the RFP matrix A came from",
       "          an upper or lower triangular matrix as follows:",
       "          = 'U': RFP A came from an upper triangular matrix;",
       "          = 'L': RFP A came from a lower triangular matrix."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0. When N = 0, DLANSF is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension ( N*(N+1)/2 );",
       "         On entry, the upper (if UPLO = 'U') or lower (if UPLO = 'L')",
       "         part of the symmetric matrix A stored in RFP format. See the",
       "         \"Notes\" below for more details.",
       "         Unchanged on exit."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "dggevx"=>
  {"summary"=>
    ["DGGEVX computes for a pair of N-by-N real nonsymmetric matrices (A,B)",
     "the generalized eigenvalues, and optionally, the left and/or right",
     "generalized eigenvectors.",
     "Optionally also, it computes a balancing transformation to improve",
     "the conditioning of the eigenvalues and eigenvectors (ILO, IHI,",
     "LSCALE, RSCALE, ABNRM, and BBNRM), reciprocal condition numbers for",
     "the eigenvalues (RCONDE), and reciprocal condition numbers for the",
     "right eigenvectors (RCONDV).",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right eigenvector v(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 A * v(j) = lambda(j) * B * v(j) .",
     "The left eigenvector u(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 u(j)**H * A  = lambda(j) * u(j)**H * B.",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"BALANC"=>
      ["[in]",
       "         BALANC is CHARACTER*1",
       "         Specifies the balance option to be performed.",
       "         = 'N':  do not diagonally scale or permute;",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale.",
       "         Computed reciprocal condition numbers will be for the",
       "         matrices after permuting and/or balancing. Permuting does",
       "         not change condition numbers (in exact arithmetic), but",
       "         balancing does."],
     "JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': none are computed;",
       "         = 'E': computed for eigenvalues only;",
       "         = 'V': computed for eigenvectors only;",
       "         = 'B': computed for eigenvalues and eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten. If JOBVL='V' or JOBVR='V'",
       "         or both, then A contains the first part of the real Schur",
       "         form of the \"balanced\" versions of the input A and B."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten. If JOBVL='V' or JOBVR='V'",
       "         or both, then B contains the second part of the real Schur",
       "         form of the \"balanced\" versions of the input A and B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHAR"=>
      ["[out]", "         ALPHAR is DOUBLE PRECISION array, dimension (N)"],
     "ALPHAI"=>
      ["[out]", "         ALPHAI is DOUBLE PRECISION array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  If ALPHAI(j) is zero, then",
       "         the j-th eigenvalue is real; if positive, then the j-th and",
       "         (j+1)-st eigenvalues are a complex conjugate pair, with",
       "         ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio",
       "         ALPHA/BETA. However, ALPHAR and ALPHAI will be always less",
       "         than and usually comparable with norm(A) in magnitude, and",
       "         BETA always less than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is DOUBLE PRECISION array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         u(j) = VL(:,j), the j-th column of VL. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         u(j) = VL(:,j)+i*VL(:,j+1) and u(j+1) = VL(:,j)-i*VL(:,j+1).",
       "         Each eigenvector will be scaled so the largest component have",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is DOUBLE PRECISION array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         v(j) = VR(:,j), the j-th column of VR. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1).",
       "         Each eigenvector will be scaled so the largest component have",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are integer values such that on exit",
       "         A(i,j) = 0 and B(i,j) = 0 if i > j and",
       "         j = 1,...,ILO-1 or i = IHI+1,...,N.",
       "         If BALANC = 'N' or 'S', ILO = 1 and IHI = N."],
     "LSCALE"=>
      ["[out]",
       "         LSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the left side of A and B.  If PL(j) is the index of the",
       "         row interchanged with row j, and DL(j) is the scaling",
       "         factor applied to row j, then",
       "           LSCALE(j) = PL(j)  for j = 1,...,ILO-1",
       "                     = DL(j)  for j = ILO,...,IHI",
       "                     = PL(j)  for j = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "RSCALE"=>
      ["[out]",
       "         RSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the right side of A and B.  If PR(j) is the index of the",
       "         column interchanged with column j, and DR(j) is the scaling",
       "         factor applied to column j, then",
       "           RSCALE(j) = PR(j)  for j = 1,...,ILO-1",
       "                     = DR(j)  for j = ILO,...,IHI",
       "                     = PR(j)  for j = IHI+1,...,N",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "ABNRM"=>
      ["[out]",
       "         ABNRM is DOUBLE PRECISION",
       "         The one-norm of the balanced matrix A."],
     "BBNRM"=>
      ["[out]",
       "         BBNRM is DOUBLE PRECISION",
       "         The one-norm of the balanced matrix B."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is DOUBLE PRECISION array, dimension (N)",
       "         If SENSE = 'E' or 'B', the reciprocal condition numbers of",
       "         the eigenvalues, stored in consecutive elements of the array.",
       "         For a complex conjugate pair of eigenvalues two consecutive",
       "         elements of RCONDE are set to the same value. Thus RCONDE(j),",
       "         RCONDV(j), and the j-th columns of VL and VR all correspond",
       "         to the j-th eigenpair.",
       "         If SENSE = 'N or 'V', RCONDE is not referenced."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is DOUBLE PRECISION array, dimension (N)",
       "         If SENSE = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the eigenvectors, stored in consecutive elements",
       "         of the array. For a complex eigenvector two consecutive",
       "         elements of RCONDV are set to the same value. If the",
       "         eigenvalues cannot be reordered to compute RCONDV(j),",
       "         RCONDV(j) is set to 0; this can only occur when the true",
       "         value would be very small anyway.",
       "         If SENSE = 'N' or 'E', RCONDV is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,2*N).",
       "         If BALANC = 'S' or 'B', or JOBVL = 'V', or JOBVR = 'V',",
       "         LWORK >= max(1,6*N).",
       "         If SENSE = 'E' or 'B', LWORK >= max(1,10*N).",
       "         If SENSE = 'V' or 'B', LWORK >= 2*N*N+8*N+16.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N+6)",
       "         If SENSE = 'E', IWORK is not referenced."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         If SENSE = 'N', BWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHAR(j), ALPHAI(j), and BETA(j)",
       "               should be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in DHGEQZ.",
       "               =N+2: error return from DTGEVC."]}},
 "cgbcon"=>
  {"summary"=>
    ["CGBCON estimates the reciprocal of the condition number of a complex",
     "general band matrix A, in either the 1-norm or the infinity-norm,",
     "using the LU factorization computed by CGBTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by CGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= N, row i of the matrix was",
       "         interchanged with row IPIV(i)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zgees"=>
  {"summary"=>
    ["ZGEES computes for an N-by-N complex nonsymmetric matrix A, the",
     "eigenvalues, the Schur form T, and, optionally, the matrix of Schur",
     "vectors Z.  This gives the Schur factorization A = Z*T*(Z**H).",
     "Optionally, it also orders the eigenvalues on the diagonal of the",
     "Schur form so that selected eigenvalues are at the top left.",
     "The leading columns of Z then form an orthonormal basis for the",
     "invariant subspace corresponding to the selected eigenvalues.",
     "A complex matrix is in Schur form if it is upper triangular."],
   "param"=>
    {"JOBVS"=>
      ["[in]",
       "         JOBVS is CHARACTER*1",
       "         = 'N': Schur vectors are not computed;",
       "         = 'V': Schur vectors are computed."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the Schur form.",
       "         = 'N': Eigenvalues are not ordered:",
       "         = 'S': Eigenvalues are ordered (see SELECT)."],
     "SELECT"=>
      ["[in]",
       "         SELECT is a LOGICAL FUNCTION of one COMPLEX*16 argument",
       "         SELECT must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'S', SELECT is used to select eigenvalues to order",
       "         to the top left of the Schur form.",
       "         IF SORT = 'N', SELECT is not referenced.",
       "         The eigenvalue W(j) is selected if SELECT(W(j)) is true."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten by its Schur form T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues for which",
       "                        SELECT is true."],
     "W"=>
      ["[out]",
       "         W is COMPLEX*16 array, dimension (N)",
       "         W contains the computed eigenvalues, in the same order that",
       "         they appear on the diagonal of the output Schur form T."],
     "VS"=>
      ["[out]",
       "         VS is COMPLEX*16 array, dimension (LDVS,N)",
       "         If JOBVS = 'V', VS contains the unitary matrix Z of Schur",
       "         vectors.",
       "         If JOBVS = 'N', VS is not referenced."],
     "LDVS"=>
      ["[in]",
       "         LDVS is INTEGER",
       "         The leading dimension of the array VS.  LDVS >= 1; if",
       "         JOBVS = 'V', LDVS >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,2*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value.",
       "         > 0: if INFO = i, and i is",
       "              <= N:  the QR algorithm failed to compute all the",
       "                     eigenvalues; elements 1:ILO-1 and i+1:N of W",
       "                     contain those eigenvalues which have converged;",
       "                     if JOBVS = 'V', VS contains the matrix which",
       "                     reduces A to its partially converged Schur form.",
       "              = N+1: the eigenvalues could not be reordered because",
       "                     some eigenvalues were too close to separate (the",
       "                     problem is very ill-conditioned);",
       "              = N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Schur form no longer satisfy",
       "                     SELECT = .TRUE..  This could also be caused by",
       "                     underflow due to scaling."]}},
 "clantr"=>
  {"summary"=>
    ["CLANTR  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "trapezoidal or triangular matrix A.",
     "   CLANTR = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANTR as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower trapezoidal.",
       "         = 'U':  Upper trapezoidal",
       "         = 'L':  Lower trapezoidal",
       "         Note that A is triangular instead of trapezoidal if M = N."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A has unit diagonal.",
       "         = 'N':  Non-unit diagonal",
       "         = 'U':  Unit diagonal"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0, and if",
       "         UPLO = 'U', M <= N.  When M = 0, CLANTR is set to zero."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0, and if",
       "         UPLO = 'L', N <= M.  When N = 0, CLANTR is set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The trapezoidal matrix A (A is triangular if M = N).",
       "         If UPLO = 'U', the leading m by n upper trapezoidal part of",
       "         the array A contains the upper trapezoidal matrix, and the",
       "         strictly lower triangular part of A is not referenced.",
       "         If UPLO = 'L', the leading m by n lower trapezoidal part of",
       "         the array A contains the lower trapezoidal matrix, and the",
       "         strictly upper triangular part of A is not referenced.  Note",
       "         that when DIAG = 'U', the diagonal elements of A are not",
       "         referenced and are assumed to be one."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= M when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "cpoequb"=>
  {"summary"=>
    ["CPOEQUB computes row and column scalings intended to equilibrate a",
     "Hermitian positive definite matrix A and reduce its condition number",
     "(with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings.",
     "This routine differs from CPOEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled diagonal entries are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The N-by-N Hermitian positive definite matrix whose scaling",
       "         factors are to be computed.  Only the diagonal elements of A",
       "         are referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is REAL",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "cla_syrpvgrw"=>
  {"summary"=>
    ["CLA_SYRPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "INFO"=>
      ["[in]",
       "         INFO is INTEGER",
       "    The value of INFO returned from CSYTRF, .i.e., the pivot in",
       "    column INFO is exactly 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by CSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by CSYTRF."],
     "WORK"=>["[in]", "         WORK is REAL array, dimension (2*N)"]}},
 "cpotri"=>
  {"summary"=>
    ["CPOTRI computes the inverse of a complex Hermitian positive definite",
     "matrix A using the Cholesky factorization A = U**H*U or A = L*L**H",
     "computed by CPOTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L from the Cholesky",
       "         factorization A = U**H*U or A = L*L**H, as computed by",
       "         CPOTRF.",
       "         On exit, the upper or lower triangle of the (Hermitian)",
       "         inverse of A, overwriting the input factor U or L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "slarft"=>
  {"summary"=>
    ["SLARFT forms the triangular factor T of a real block reflector H",
     "of order n, which is defined as a product of k elementary reflectors.",
     "If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;",
     "If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.",
     "If STOREV = 'C', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th column of the array V, and",
     "   H  =  I - V * T * V**T",
     "If STOREV = 'R', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th row of the array V, and",
     "   H  =  I - V**T * T * V"],
   "param"=>
    {"DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies the order in which the elementary reflectors are",
       "         multiplied to form the block reflector:",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Specifies how the vectors which define the elementary",
       "         reflectors are stored (see also Further Details):",
       "         = 'C': columnwise",
       "         = 'R': rowwise"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the block reflector H. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the triangular factor T (= the number of",
       "         elementary reflectors). K >= 1."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension",
       "                              (LDV,K) if STOREV = 'C'",
       "                              (LDV,N) if STOREV = 'R'",
       "         The matrix V. See further details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,K)",
       "         The k by k triangular factor T of the block reflector.",
       "         If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is",
       "         lower triangular. The rest of the array is not used."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."]}},
 "dlabrd"=>
  {"summary"=>
    ["DLABRD reduces the first NB rows and columns of a real general",
     "m by n matrix A to upper or lower bidiagonal form by an orthogonal",
     "transformation Q**T * A * P, and returns the matrices X and Y which",
     "are needed to apply the transformation to the unreduced part of A.",
     "If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower",
     "bidiagonal form.",
     "This is an auxiliary routine called by DGEBRD"],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of leading rows and columns of A to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the m by n general matrix to be reduced.",
       "         On exit, the first NB rows and columns of the matrix are",
       "         overwritten; the rest of the array is unchanged.",
       "         If m >= n, elements on and below the diagonal in the first NB",
       "           columns, with the array TAUQ, represent the orthogonal",
       "           matrix Q as a product of elementary reflectors; and",
       "           elements above the diagonal in the first NB rows, with the",
       "           array TAUP, represent the orthogonal matrix P as a product",
       "           of elementary reflectors.",
       "         If m < n, elements below the diagonal in the first NB",
       "           columns, with the array TAUQ, represent the orthogonal",
       "           matrix Q as a product of elementary reflectors, and",
       "           elements on and above the diagonal in the first NB rows,",
       "           with the array TAUP, represent the orthogonal matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (NB)",
       "         The diagonal elements of the first NB rows and columns of",
       "         the reduced matrix.  D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (NB)",
       "         The off-diagonal elements of the first NB rows and columns of",
       "         the reduced matrix."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is DOUBLE PRECISION array dimension (NB)",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is DOUBLE PRECISION array, dimension (NB)",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix P. See Further Details."],
     "X"=>
      ["[out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NB)",
       "         The m-by-nb matrix X required to update the unreduced part",
       "         of A."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X. LDX >= max(1,M)."],
     "Y"=>
      ["[out]",
       "         Y is DOUBLE PRECISION array, dimension (LDY,NB)",
       "         The n-by-nb matrix Y required to update the unreduced part",
       "         of A."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "         The leading dimension of the array Y. LDY >= max(1,N)."]}},
 "dlatrs"=>
  {"summary"=>
    ["DLATRS solves one of the triangular systems",
     "   A *x = s*b  or  A**T *x = s*b",
     "with scaling to prevent overflow.  Here A is an upper or lower",
     "triangular matrix, A**T denotes the transpose of A, x and b are",
     "n-element vectors, and s is a scaling factor, usually less than",
     "or equal to 1, chosen so that the components of x will be less than",
     "the overflow threshold.  If the unscaled problem will not cause",
     "overflow, the Level 2 BLAS routine DTRSV is called.  If the matrix A",
     "is singular (A(j,j) = 0 for some j), then s is set to 0 and a",
     "non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b  (No transpose)",
       "         = 'T':  Solve A**T* x = s*b  (Transpose)",
       "         = 'C':  Solve A**T* x = s*b  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading n by n",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading n by n lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max (1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b  or  A**T* x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is DOUBLE PRECISION array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "zsyrfsx"=>
  {"summary"=>
    ["   ZSYRFSX improves the computed solution to a system of linear",
     "   equations when the coefficient matrix is symmetric indefinite, and",
     "   provides error bounds and backward error estimates for the",
     "   solution.  In addition to normwise error bound, the code provides",
     "   maximum componentwise error bound if possible.  See comments for",
     "   ERR_BNDS_NORM and ERR_BNDS_COMP for details of the error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED and S",
     "   below. In this case, the solution and error bounds returned are",
     "   for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'Y':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(S) * A * diag(S).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "    upper triangular part of A contains the upper triangular",
       "    part of the matrix A, and the strictly lower triangular",
       "    part of A is not referenced.  If UPLO = 'L', the leading",
       "    N-by-N lower triangular part of A contains the lower",
       "    triangular part of the matrix A, and the strictly upper",
       "    triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The factored form of the matrix A.  AF contains the block",
       "    diagonal matrix D and the multipliers used to obtain the",
       "    factor U or L from the factorization A = U*D*U**T or A =",
       "    L*D*L**T as computed by DSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by DSYTRF."],
     "S"=>
      ["[in,out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "    The scale factors for A.  If EQUED = 'Y', A is multiplied on",
       "    the left and right by diag(S).  S is an input argument if FACT =",
       "    'F'; otherwise, S is an output argument.  If FACT = 'F' and EQUED",
       "    = 'Y', each element of S must be positive.  If S is output, each",
       "    element of S is a power of the radix. If S is input, each element",
       "    of S should be a power of the radix to ensure a reliable solution",
       "    and error estimates. Scaling by powers of the radix does not cause",
       "    rounding errors unless the result underflows or overflows.",
       "    Rounding errors during scaling lead to refining with a matrix that",
       "    is not equivalent to the input matrix, producing error estimates",
       "    that may not be reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by DGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is DOUBLE PRECISION array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0D+0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "clatbs"=>
  {"summary"=>
    ["CLATBS solves one of the triangular systems",
     "   A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b,",
     "with scaling to prevent overflow, where A is an upper or lower",
     "triangular band matrix.  Here A**T denotes the transpose of A, x and b",
     "are n-element vectors, and s is a scaling factor, usually less than",
     "or equal to 1, chosen so that the components of x will be less than",
     "the overflow threshold.  If the unscaled problem will not cause",
     "overflow, the Level 2 BLAS routine CTBSV is called.  If the matrix A",
     "is singular (A(j,j) = 0 for some j), then s is set to 0 and a",
     "non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b     (No transpose)",
       "         = 'T':  Solve A**T * x = s*b  (Transpose)",
       "         = 'C':  Solve A**H * x = s*b  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of subdiagonals or superdiagonals in the",
       "         triangular matrix A.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first KD+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b,  A**T * x = s*b,  or  A**H * x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is REAL array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "spbsv"=>
  {"summary"=>
    ["SPBSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite band matrix and X",
     "and B are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L * L**T,  if UPLO = 'L',",
     "where U is an upper triangular band matrix, and L is a lower",
     "triangular band matrix, with the same number of superdiagonals or",
     "subdiagonals as A.  The factored form of A is then used to solve the",
     "system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(KD+1+i-j,j) = A(i,j) for max(1,j-KD)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(N,j+KD).",
       "         See below for further details.",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**T*U or A = L*L**T of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "chetri2"=>
  {"summary"=>
    ["CHETRI2 computes the inverse of a COMPLEX hermitian indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "CHETRF. CHETRI2 set the LEADING DIMENSION of the workspace",
     "before calling CHETRI2X that actually computes the inverse."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CHETRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NB structure of D",
       "         as determined by CHETRF."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX array, dimension (N+NB+1)*(NB+3)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         WORK is size >= (N+NB+1)*(NB+3)",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "          calculates:",
       "             - the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array,",
       "             - and no error message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "dsytrs2"=>
  {"summary"=>
    ["DSYTRS2 solves a system of linear equations A*X = B with a real",
     "symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by DSYTRF and converted by DSYCONV."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by DSYTRF.",
       "         Note that A is input / output. This might be counter-intuitive,",
       "         and one may think that A is input only. A is input / output. This",
       "         is because, at the start of the subroutine, we permute A in a",
       "         \"better\" form and then we permute A back to its original form at",
       "         the end."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "csysv_aa"=>
  {"summary"=>
    ["CSYSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "Aasen's algorithm is used to factor A as",
     "   A = U * T * U**T,  if UPLO = 'U', or",
     "   A = L * T * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is symmetric tridiagonal. The factored",
     "form of A is then used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the tridiagonal matrix T and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*T*U**T or A = L*T*L**T as computed by",
       "         CSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= MAX(2*N, 3*N-2), and for",
       "         the best performance, LWORK >= max(1,N*NB), where NB is",
       "         the optimal blocksize for CSYTRF_AA.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "dtrsen"=>
  {"summary"=>
    ["DTRSEN reorders the real Schur factorization of a real matrix",
     "A = Q*T*Q**T, so that a selected cluster of eigenvalues appears in",
     "the leading diagonal blocks of the upper quasi-triangular matrix T,",
     "and the leading columns of Q form an orthonormal basis of the",
     "corresponding right invariant subspace.",
     "Optionally the routine computes the reciprocal condition numbers of",
     "the cluster of eigenvalues and/or the invariant subspace.",
     "T must be in Schur canonical form (as returned by DHSEQR), that is,",
     "block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each",
     "2-by-2 diagonal block has its diagonal elements equal and its",
     "off-diagonal elements of opposite sign."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for the",
       "         cluster of eigenvalues (S) or the invariant subspace (SEP):",
       "         = 'N': none;",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for invariant subspace only (SEP);",
       "         = 'B': for both eigenvalues and invariant subspace (S and",
       "                SEP)."],
     "COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'V': update the matrix Q of Schur vectors;",
       "         = 'N': do not update Q."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         SELECT specifies the eigenvalues in the selected cluster. To",
       "         select a real eigenvalue w(j), SELECT(j) must be set to",
       "         .TRUE.. To select a complex conjugate pair of eigenvalues",
       "         w(j) and w(j+1), corresponding to a 2-by-2 diagonal block,",
       "         either SELECT(j) or SELECT(j+1) or both must be set to",
       "         .TRUE.; a complex conjugate pair of eigenvalues must be",
       "         either both included in the cluster or both excluded."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in,out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         On entry, the upper quasi-triangular matrix T, in Schur",
       "         canonical form.",
       "         On exit, T is overwritten by the reordered matrix T, again in",
       "         Schur canonical form, with the selected eigenvalues in the",
       "         leading diagonal blocks."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         On entry, if COMPQ = 'V', the matrix Q of Schur vectors.",
       "         On exit, if COMPQ = 'V', Q has been postmultiplied by the",
       "         orthogonal transformation matrix which reorders T; the",
       "         leading M columns of Q form an orthonormal basis for the",
       "         specified invariant subspace.",
       "         If COMPQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= 1; and if COMPQ = 'V', LDQ >= N."],
     "WR"=>["[out]", "         WR is DOUBLE PRECISION array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is DOUBLE PRECISION array, dimension (N)",
       "         The real and imaginary parts, respectively, of the reordered",
       "         eigenvalues of T. The eigenvalues are stored in the same",
       "         order as on the diagonal of T, with WR(i) = T(i,i) and, if",
       "         T(i:i+1,i:i+1) is a 2-by-2 diagonal block, WI(i) > 0 and",
       "         WI(i+1) = -WI(i). Note that if a complex eigenvalue is",
       "         sufficiently ill-conditioned, then its value may differ",
       "         significantly from its value before reordering."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The dimension of the specified invariant subspace.",
       "         0 < = M <= N."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION",
       "         If JOB = 'E' or 'B', S is a lower bound on the reciprocal",
       "         condition number for the selected cluster of eigenvalues.",
       "         S cannot underestimate the true reciprocal condition number",
       "         by more than a factor of sqrt(N). If M = 0 or N, S = 1.",
       "         If JOB = 'N' or 'V', S is not referenced."],
     "SEP"=>
      ["[out]",
       "         SEP is DOUBLE PRECISION",
       "         If JOB = 'V' or 'B', SEP is the estimated reciprocal",
       "         condition number of the specified invariant subspace. If",
       "         M = 0 or N, SEP = norm(T).",
       "         If JOB = 'N' or 'E', SEP is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If JOB = 'N', LWORK >= max(1,N);",
       "         if JOB = 'E', LWORK >= max(1,M*(N-M));",
       "         if JOB = 'V' or 'B', LWORK >= max(1,2*M*(N-M)).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOB = 'N' or 'E', LIWORK >= 1;",
       "         if JOB = 'V' or 'B', LIWORK >= max(1,M*(N-M)).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         = 1: reordering of T failed because some eigenvalues are too",
       "              close to separate (the problem is very ill-conditioned);",
       "              T may have been partially reordered, and WR and WI",
       "              contain the eigenvalues in the same order as in T; S and",
       "              SEP (if requested) are set to zero."]}},
 "ztprfs"=>
  {"summary"=>
    ["ZTPRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular packed",
     "coefficient matrix.",
     "The solution matrix X must be computed by ZTPTRS or some other",
     "means before entering this routine.  ZTPRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slasda"=>
  {"summary"=>
    ["Using a divide and conquer approach, SLASDA computes the singular",
     "value decomposition (SVD) of a real upper bidiagonal N-by-M matrix",
     "B with diagonal D and offdiagonal E, where M = N + SQRE. The",
     "algorithm computes the singular values in the SVD B = U * S * VT.",
     "The orthogonal matrices U and VT are optionally computed in",
     "compact form.",
     "A related subroutine, SLASD0, computes the singular values and",
     "the singular vectors in explicit form."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether singular vectors are to be computed",
       "        in compact form, as follows",
       "        = 0: Compute singular values only.",
       "        = 1: Compute singular vectors of upper bidiagonal",
       "             matrix in compact form."],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        The maximum size of the subproblems at the bottom of the",
       "        computation tree."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The row dimension of the upper bidiagonal matrix. This is",
       "        also the dimension of the main diagonal array D."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        Specifies the column dimension of the bidiagonal matrix.",
       "        = 0: The bidiagonal matrix has column dimension M = N;",
       "        = 1: The bidiagonal matrix has column dimension M = N + 1."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension ( N )",
       "        On entry D contains the main diagonal of the bidiagonal",
       "        matrix. On exit D, if INFO = 0, contains its singular values."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension ( M-1 )",
       "        Contains the subdiagonal entries of the bidiagonal matrix.",
       "        On exit, E has been destroyed."],
     "U"=>
      ["[out]",
       "         U is REAL array,",
       "        dimension ( LDU, SMLSIZ ) if ICOMPQ = 1, and not referenced",
       "        if ICOMPQ = 0. If ICOMPQ = 1, on exit, U contains the left",
       "        singular vector matrices of all subproblems at the bottom",
       "        level."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER, LDU = > N.",
       "        The leading dimension of arrays U, VT, DIFL, DIFR, POLES,",
       "        GIVNUM, and Z."],
     "VT"=>
      ["[out]",
       "         VT is REAL array,",
       "        dimension ( LDU, SMLSIZ+1 ) if ICOMPQ = 1, and not referenced",
       "        if ICOMPQ = 0. If ICOMPQ = 1, on exit, VT**T contains the right",
       "        singular vector matrices of all subproblems at the bottom",
       "        level."],
     "K"=>
      ["[out]",
       "         K is INTEGER array, dimension ( N )",
       "        if ICOMPQ = 1 and dimension 1 if ICOMPQ = 0.",
       "        If ICOMPQ = 1, on exit, K(I) is the dimension of the I-th",
       "        secular equation on the computation tree."],
     "DIFL"=>
      ["[out]",
       "         DIFL is REAL array, dimension ( LDU, NLVL ),",
       "        where NLVL = floor(log_2 (N/SMLSIZ)))."],
     "DIFR"=>
      ["[out]",
       "         DIFR is REAL array,",
       "                 dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1 and",
       "                 dimension ( N ) if ICOMPQ = 0.",
       "        If ICOMPQ = 1, on exit, DIFL(1:N, I) and DIFR(1:N, 2 * I - 1)",
       "        record distances between singular values on the I-th",
       "        level and singular values on the (I -1)-th level, and",
       "        DIFR(1:N, 2 * I ) contains the normalizing factors for",
       "        the right singular vector matrix. See SLASD8 for details."],
     "Z"=>
      ["[out]",
       "         Z is REAL array,",
       "                 dimension ( LDU, NLVL ) if ICOMPQ = 1 and",
       "                 dimension ( N ) if ICOMPQ = 0.",
       "        The first K elements of Z(1, I) contain the components of",
       "        the deflation-adjusted updating row vector for subproblems",
       "        on the I-th level."],
     "POLES"=>
      ["[out]",
       "         POLES is REAL array,",
       "        dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1, and not referenced",
       "        if ICOMPQ = 0. If ICOMPQ = 1, on exit, POLES(1, 2*I - 1) and",
       "        POLES(1, 2*I) contain  the new and old singular values",
       "        involved in the secular equations on the I-th level."],
     "GIVPTR"=>
      ["[out]",
       "         GIVPTR is INTEGER array,",
       "        dimension ( N ) if ICOMPQ = 1, and not referenced if",
       "        ICOMPQ = 0. If ICOMPQ = 1, on exit, GIVPTR( I ) records",
       "        the number of Givens rotations performed on the I-th",
       "        problem on the computation tree."],
     "GIVCOL"=>
      ["[out]",
       "         GIVCOL is INTEGER array,",
       "        dimension ( LDGCOL, 2 * NLVL ) if ICOMPQ = 1, and not",
       "        referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I,",
       "        GIVCOL(1, 2 *I - 1) and GIVCOL(1, 2 *I) record the locations",
       "        of Givens rotations performed on the I-th level on the",
       "        computation tree."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER, LDGCOL = > N.",
       "        The leading dimension of arrays GIVCOL and PERM."],
     "PERM"=>
      ["[out]",
       "         PERM is INTEGER array, dimension ( LDGCOL, NLVL )",
       "        if ICOMPQ = 1, and not referenced",
       "        if ICOMPQ = 0. If ICOMPQ = 1, on exit, PERM(1, I) records",
       "        permutations done on the I-th level of the computation tree."],
     "GIVNUM"=>
      ["[out]",
       "         GIVNUM is REAL array,",
       "        dimension ( LDU,  2 * NLVL ) if ICOMPQ = 1, and not",
       "        referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I,",
       "        GIVNUM(1, 2 *I - 1) and GIVNUM(1, 2 *I) record the C- and S-",
       "        values of Givens rotations performed on the I-th level on",
       "        the computation tree."],
     "C"=>
      ["[out]",
       "         C is REAL array,",
       "        dimension ( N ) if ICOMPQ = 1, and dimension 1 if ICOMPQ = 0.",
       "        If ICOMPQ = 1 and the I-th subproblem is not square, on exit,",
       "        C( I ) contains the C-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension ( N ) if",
       "        ICOMPQ = 1, and dimension 1 if ICOMPQ = 0. If ICOMPQ = 1",
       "        and the I-th subproblem is not square, on exit, S( I )",
       "        contains the S-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension",
       "        (6 * N + (SMLSIZ + 1)*(SMLSIZ + 1))."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (7*N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, a singular value did not converge"]}},
 "zlahr2"=>
  {"summary"=>
    ["ZLAHR2 reduces the first NB columns of A complex general n-BY-(n-k+1)",
     "matrix A so that elements below the k-th subdiagonal are zero. The",
     "reduction is performed by an unitary similarity transformation",
     "Q**H * A * Q. The routine returns the matrices V and T which determine",
     "Q as a block reflector I - V*T*V**H, and also the matrix Y = A * V * T.",
     "This is an auxiliary routine called by ZGEHRD."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The offset for the reduction. Elements below the k-th",
       "         subdiagonal in the first NB columns are reduced to zero.",
       "         K < N."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of columns to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N-K+1)",
       "         On entry, the n-by-(n-k+1) general matrix A.",
       "         On exit, the elements on and above the k-th subdiagonal in",
       "         the first NB columns are overwritten with the corresponding",
       "         elements of the reduced matrix; the elements below the k-th",
       "         subdiagonal, with the array TAU, represent the matrix Q as a",
       "         product of elementary reflectors. The other columns of A are",
       "         unchanged. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (NB)",
       "         The scalar factors of the elementary reflectors. See Further",
       "         Details."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,NB)",
       "         The upper triangular matrix T."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "Y"=>
      ["[out]",
       "         Y is COMPLEX*16 array, dimension (LDY,NB)",
       "         The n-by-nb matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "         The leading dimension of the array Y. LDY >= N."]}},
 "sggesx"=>
  {"summary"=>
    ["SGGESX computes for a pair of N-by-N real nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, the real Schur form (S,T), and,",
     "optionally, the left and/or right matrices of Schur vectors (VSL and",
     "VSR).  This gives the generalized Schur factorization",
     "     (A,B) = ( (VSL) S (VSR)**T, (VSL) T (VSR)**T )",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "quasi-triangular matrix S and the upper triangular matrix T; computes",
     "a reciprocal condition number for the average of the selected",
     "eigenvalues (RCONDE); and computes a reciprocal condition number for",
     "the right and left deflating subspaces corresponding to the selected",
     "eigenvalues (RCONDV). The leading columns of VSL and VSR then form",
     "an orthonormal basis for the corresponding left and right eigenspaces",
     "(deflating subspaces).",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0 or for both being zero.",
     "A pair of matrices (S,T) is in generalized real Schur form if T is",
     "upper triangular with non-negative diagonal and S is block upper",
     "triangular with 1-by-1 and 2-by-2 blocks.  1-by-1 blocks correspond",
     "to real generalized eigenvalues, while 2-by-2 blocks of S will be",
     "\"standardized\" by making the corresponding elements of T have the",
     "form:",
     "        [  a  0  ]",
     "        [  0  b  ]",
     "and the pair of corresponding 2-by-2 blocks in S and T will have a",
     "complex conjugate pair of generalized eigenvalues."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG)."],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is procedure) LOGICAL FUNCTION of three REAL arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         An eigenvalue (ALPHAR(j)+ALPHAI(j))/BETA(j) is selected if",
       "         SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) is true; i.e. if either",
       "         one of a complex conjugate pair of eigenvalues is selected,",
       "         then both complex eigenvalues are selected.",
       "         Note that a selected complex eigenvalue may no longer satisfy",
       "         SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) = .TRUE. after ordering,",
       "         since ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned), in this",
       "         case INFO is set to N+3."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N' : None are computed;",
       "         = 'E' : Computed for average of selected eigenvalues only;",
       "         = 'V' : Computed for selected deflating subspaces only;",
       "         = 'B' : Computed for both.",
       "         If SENSE = 'E', 'V', or 'B', SORT must equal 'S'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true.  (Complex conjugate pairs for which",
       "         SELCTG is true for either eigenvalue count as 2.)"],
     "ALPHAR"=>["[out]", "         ALPHAR is REAL array, dimension (N)"],
     "ALPHAI"=>["[out]", "         ALPHAI is REAL array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  ALPHAR(j) + ALPHAI(j)*i",
       "         and BETA(j),j=1,...,N  are the diagonals of the complex Schur",
       "         form (S,T) that would result if the 2-by-2 diagonal blocks of",
       "         the real Schur form of (A,B) were further reduced to",
       "         triangular form using 2-by-2 complex unitary transformations.",
       "         If ALPHAI(j) is zero, then the j-th eigenvalue is real; if",
       "         positive, then the j-th and (j+1)-st eigenvalues are a",
       "         complex conjugate pair, with ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio.",
       "         However, ALPHAR and ALPHAI will be always less than and",
       "         usually comparable with norm(A) in magnitude, and BETA always",
       "         less than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is REAL array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >=1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is REAL array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is REAL array, dimension ( 2 )",
       "         If SENSE = 'E' or 'B', RCONDE(1) and RCONDE(2) contain the",
       "         reciprocal condition numbers for the average of the selected",
       "         eigenvalues.",
       "         Not referenced if SENSE = 'N' or 'V'."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is REAL array, dimension ( 2 )",
       "         If SENSE = 'V' or 'B', RCONDV(1) and RCONDV(2) contain the",
       "         reciprocal condition numbers for the selected deflating",
       "         subspaces.",
       "         Not referenced if SENSE = 'N' or 'E'."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N = 0, LWORK >= 1, else if SENSE = 'E', 'V', or 'B',",
       "         LWORK >= max( 8*N, 6*N+16, 2*SDIM*(N-SDIM) ), else",
       "         LWORK >= max( 8*N, 6*N+16 ).",
       "         Note that 2*SDIM*(N-SDIM) <= N*N/2.",
       "         Note also that an error is only returned if",
       "         LWORK < max( 8*N, 6*N+16), but if SENSE = 'E' or 'V' or 'B'",
       "         this may not be large enough.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the bound on the optimal size of the WORK",
       "         array and the minimum size of the IWORK array, returns these",
       "         values as the first entries of the WORK and IWORK arrays, and",
       "         no error message related to LWORK or LIWORK is issued by",
       "         XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If SENSE = 'N' or N = 0, LIWORK >= 1, otherwise",
       "         LIWORK >= N+6.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the bound on the optimal size of the",
       "         WORK array and the minimum size of the IWORK array, returns",
       "         these values as the first entries of the WORK and IWORK",
       "         arrays, and no error message related to LWORK or LIWORK is",
       "         issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHAR(j), ALPHAI(j), and BETA(j) should",
       "               be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in SHGEQZ",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in STGSEN."]}},
 "zgtsvx"=>
  {"summary"=>
    ["ZGTSVX uses the LU factorization to compute the solution to a complex",
     "system of linear equations A * X = B, A**T * X = B, or A**H * X = B,",
     "where A is a tridiagonal matrix of order N and X and B are N-by-NRHS",
     "matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "clarfx"=>
  {"summary"=>
    ["CLARFX applies a complex elementary reflector H to a complex m by n",
     "matrix C, from either the left or the right. H is represented in the",
     "form",
     "      H = I - tau * v * v**H",
     "where tau is a complex scalar and v is a complex vector.",
     "If tau = 0, then H is taken to be the unit matrix",
     "This version uses inline code if H has order < 11."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension (M) if SIDE = 'L'",
       "                                       or (N) if SIDE = 'R'",
       "         The vector v in the representation of H."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDA >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (N) if SIDE = 'L'",
       "                                           or (M) if SIDE = 'R'",
       "         WORK is not referenced if H has order < 11."]}},
 "slarf"=>
  {"summary"=>
    ["SLARF applies a real elementary reflector H to a real m by n matrix",
     "C, from either the left or the right. H is represented in the form",
     "      H = I - tau * v * v**T",
     "where tau is a real scalar and v is a real vector.",
     "If tau = 0, then H is taken to be the unit matrix."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension",
       "                    (1 + (M-1)*abs(INCV)) if SIDE = 'L'",
       "                 or (1 + (N-1)*abs(INCV)) if SIDE = 'R'",
       "         The vector v in the representation of H. V is not used if",
       "         TAU = 0."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between elements of v. INCV <> 0."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension",
       "                        (N) if SIDE = 'L'",
       "                     or (M) if SIDE = 'R'"]}},
 "zungl2"=>
  {"summary"=>
    ["ZUNGL2 generates an m-by-n complex matrix Q with orthonormal rows,",
     "which is defined as the first m rows of a product of k elementary",
     "reflectors of order n",
     "      Q  =  H(k)**H . . . H(2)**H H(1)**H",
     "as returned by ZGELQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the i-th row must contain the vector which defines",
       "         the elementary reflector H(i), for i = 1,2,...,k, as returned",
       "         by ZGELQF in the first k rows of its array argument A.",
       "         On exit, the m by n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGELQF."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "dstemr"=>
  {"summary"=>
    ["DSTEMR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix T. Any such unreduced matrix has",
     "a well defined set of pairwise different real eigenvalues, the corresponding",
     "real eigenvectors are pairwise orthogonal.",
     "The spectrum may be computed either completely or partially by specifying",
     "either an interval (VL,VU] or a range of indices IL:IU for the desired",
     "eigenvalues.",
     "Depending on the number of desired eigenvalues, these are computed either",
     "by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are",
     "computed by the use of various suitable L D L^T factorizations near clusters",
     "of close eigenvalues (referred to as RRRs, Relatively Robust",
     "Representations). An informal sketch of the algorithm follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "For more details, see:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Further Details",
     "1.DSTEMR works only on machines which follow IEEE-754",
     "floating-point standard in their handling of infinities and NaNs.",
     "This permits the use of efficient inner loops avoiding a check for",
     "zero divisors."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal matrix",
       "         T. On exit, D is overwritten."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the tridiagonal",
       "         matrix T in elements 1 to N-1 of E. E(N) need not be set on",
       "         input, but is used internally as workspace.",
       "         On exit, E is overwritten."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', and if INFO = 0, then the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix T",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and can be computed with a workspace",
       "         query by setting NZC = -1, see below."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', then LDZ >= max(1,N)."],
     "NZC"=>
      ["[in]",
       "         NZC is INTEGER",
       "         The number of eigenvectors to be held in the array Z.",
       "         If RANGE = 'A', then NZC >= max(1,N).",
       "         If RANGE = 'V', then NZC >= the number of eigenvalues in (VL,VU].",
       "         If RANGE = 'I', then NZC >= IU-IL+1.",
       "         If NZC = -1, then a workspace query is assumed; the",
       "         routine calculates the number of columns of the array Z that",
       "         are needed to hold the eigenvectors.",
       "         This value is returned as the first entry of the Z array, and",
       "         no error message related to NZC is issued by XERBLA."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER ARRAY, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th computed eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is relevant in the case when the matrix",
       "         is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0."],
     "TRYRAC"=>
      ["[in,out]",
       "         TRYRAC is LOGICAL",
       "         If TRYRAC.EQ..TRUE., indicates that the code should check whether",
       "         the tridiagonal matrix defines its eigenvalues to high relative",
       "         accuracy.  If so, the code uses relative-accuracy preserving",
       "         algorithms that might be (a bit) slower depending on the matrix.",
       "         If the matrix does not define its eigenvalues to high relative",
       "         accuracy, the code can uses possibly faster algorithms.",
       "         If TRYRAC.EQ..FALSE., the code is not required to guarantee",
       "         relatively accurate eigenvalues and can use the fastest possible",
       "         techniques.",
       "         On exit, a .TRUE. TRYRAC will be set to .FALSE. if the matrix",
       "         does not define its eigenvalues to high relative accuracy."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal",
       "         (and minimal) LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,18*N)",
       "         if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (LIWORK)",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N)",
       "         if the eigenvectors are desired, and LIWORK >= max(1,8*N)",
       "         if only the eigenvalues are to be computed.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = 1X, internal error in DLARRE,",
       "               if INFO = 2X, internal error in DLARRV.",
       "               Here, the digit X = ABS( IINFO ) < 10, where IINFO is",
       "               the nonzero error code returned by DLARRE or",
       "               DLARRV, respectively."]}},
 "csytrs_aa"=>
  {"summary"=>
    ["CSYTRS_AA solves a system of linear equations A*X = B with a complex",
     "symmetric matrix A using the factorization A = U*T*U**T or",
     "A = L*T*L**T computed by CSYTRF_AA."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*T*U**T;",
       "         = 'L':  Lower triangular, form is A = L*T*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         Details of factors computed by CSYTRF_AA."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges as computed by CSYTRF_AA."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[in]", "         WORK is DOUBLE array, dimension (MAX(1,LWORK))"],
     "LWORK"=>["[in]", "         LWORK is INTEGER, LWORK >= MAX(1,3*N-2)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cheevx"=>
  {"summary"=>
    ["CHEEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian matrix A.  Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= 1, when N <= 1;",
       "         otherwise 2*N.",
       "         For optimal efficiency, LWORK >= (NB+1)*N,",
       "         where NB is the max of the blocksize for CHETRD and for",
       "         CUNMTR as returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "sgtcon"=>
  {"summary"=>
    ["SGTCON estimates the reciprocal of the condition number of a real",
     "tridiagonal matrix A using the LU factorization as computed by",
     "SGTTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "DL"=>
      ["[in]",
       "         DL is REAL array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A as computed by SGTTRF."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is REAL array, dimension (N-1)",
       "         The (n-1) elements of the first superdiagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is REAL array, dimension (N-2)",
       "         The (n-2) elements of the second superdiagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ssycon_3"=>
  {"summary"=>
    ["SSYCON_3 estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric matrix A using the factorization",
     "computed by DSYTRF_RK or DSYTRF_BK:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).",
     "This routine uses BLAS3 solver SSYTRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**T)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**T)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by SSYTRF_RK and SSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF_RK or SSYTRF_BK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slals0"=>
  {"summary"=>
    ["SLALS0 applies back the multiplying factors of either the left or the",
     "right singular vector matrix of a diagonal matrix appended by a row",
     "to the right hand side matrix B in solving the least squares problem",
     "using the divide-and-conquer SVD approach.",
     "For the left singular vector matrix, three types of orthogonal",
     "matrices are involved:",
     "(1L) Givens rotations: the number of such rotations is GIVPTR; the",
     "     pairs of columns/rows they were applied to are stored in GIVCOL;",
     "     and the C- and S-values of these rotations are stored in GIVNUM.",
     "(2L) Permutation. The (NL+1)-st row of B is to be moved to the first",
     "     row, and for J=2:N, PERM(J)-th row of B is to be moved to the",
     "     J-th row.",
     "(3L) The left singular vector matrix of the remaining matrix.",
     "For the right singular vector matrix, four types of orthogonal",
     "matrices are involved:",
     "(1R) The right singular vector matrix of the remaining matrix.",
     "(2R) If SQRE = 1, one extra Givens rotation to generate the right",
     "     null space.",
     "(3R) The inverse transformation of (2L).",
     "(4R) The inverse transformation of (1L)."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether singular vectors are to be computed in",
       "        factored form:",
       "        = 0: Left singular vector matrix.",
       "        = 1: Right singular vector matrix."],
     "NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block. NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block. NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has row dimension N = NL + NR + 1,",
       "        and column dimension M = N + SQRE."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B and BX. NRHS must be at least 1."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension ( LDB, NRHS )",
       "        On input, B contains the right hand sides of the least",
       "        squares problem in rows 1 through M. On output, B contains",
       "        the solution X in rows 1 through N."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B. LDB must be at least",
       "        max(1,MAX( M, N ) )."],
     "BX"=>["[out]", "         BX is REAL array, dimension ( LDBX, NRHS )"],
     "LDBX"=>
      ["[in]",
       "         LDBX is INTEGER",
       "        The leading dimension of BX."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension ( N )",
       "        The permutations (from deflation and sorting) applied",
       "        to the two blocks."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER",
       "        The number of Givens rotations which took place in this",
       "        subproblem."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )",
       "        Each pair of numbers indicates a pair of rows/columns",
       "        involved in a Givens rotation."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER",
       "        The leading dimension of GIVCOL, must be at least N."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is REAL array, dimension ( LDGNUM, 2 )",
       "        Each number indicates the C or S value used in the",
       "        corresponding Givens rotation."],
     "LDGNUM"=>
      ["[in]",
       "         LDGNUM is INTEGER",
       "        The leading dimension of arrays DIFR, POLES and",
       "        GIVNUM, must be at least K."],
     "POLES"=>
      ["[in]",
       "         POLES is REAL array, dimension ( LDGNUM, 2 )",
       "        On entry, POLES(1:K, 1) contains the new singular",
       "        values obtained from solving the secular equation, and",
       "        POLES(1:K, 2) is an array containing the poles in the secular",
       "        equation."],
     "DIFL"=>
      ["[in]",
       "         DIFL is REAL array, dimension ( K ).",
       "        On entry, DIFL(I) is the distance between I-th updated",
       "        (undeflated) singular value and the I-th (undeflated) old",
       "        singular value."],
     "DIFR"=>
      ["[in]",
       "         DIFR is REAL array, dimension ( LDGNUM, 2 ).",
       "        On entry, DIFR(I, 1) contains the distances between I-th",
       "        updated (undeflated) singular value and the I+1-th",
       "        (undeflated) old singular value. And DIFR(I, 2) is the",
       "        normalizing factor for the I-th right singular vector."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension ( K )",
       "        Contain the components of the deflation-adjusted updating row",
       "        vector."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "        Contains the dimension of the non-deflated matrix,",
       "        This is the order of the related secular equation. 1 <= K <=N."],
     "C"=>
      ["[in]",
       "         C is REAL",
       "        C contains garbage if SQRE =0 and the C-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "S"=>
      ["[in]",
       "         S is REAL",
       "        S contains garbage if SQRE =0 and the S-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension ( K )"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slarrv"=>
  {"summary"=>
    ["SLARRV computes the eigenvectors of the tridiagonal matrix",
     "T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T.",
     "The input eigenvalues should have been computed by SLARRE."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         Lower bound of the interval that contains the desired",
       "         eigenvalues. VL < VU. Needed to compute gaps on the left or right",
       "         end of the extremal eigenvalues in the desired RANGE."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         Upper bound of the interval that contains the desired",
       "         eigenvalues. VL < VU. Needed to compute gaps on the left or right",
       "         end of the extremal eigenvalues in the desired RANGE."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the N diagonal elements of the diagonal matrix D.",
       "         On exit, D may be overwritten."],
     "L"=>
      ["[in,out]",
       "         L is REAL array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the unit",
       "         bidiagonal matrix L are in elements 1 to N-1 of L",
       "         (if the matrix is not split.) At the end of each block",
       "         is stored the corresponding shift as given by SLARRE.",
       "         On exit, L is overwritten."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "         The minimum pivot allowed in the Sturm sequence."],
     "ISPLIT"=>
      ["[in]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into blocks.",
       "         The first block consists of rows/columns 1 to",
       "         ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1",
       "         through ISPLIT( 2 ), etc."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of input eigenvalues.  0 <= M <= N."],
     "DOL"=>["[in]", "         DOL is INTEGER"],
     "DOU"=>
      ["[in]",
       "         DOU is INTEGER",
       "         If the user wants to compute only selected eigenvectors from all",
       "         the eigenvalues supplied, he can specify an index range DOL:DOU.",
       "         Or else the setting DOL=1, DOU=M should be applied.",
       "         Note that DOL and DOU refer to the order in which the eigenvalues",
       "         are stored in W.",
       "         If the user wants to compute only selected eigenpairs, then",
       "         the columns DOL-1 to DOU+1 of the eigenvector space Z contain the",
       "         computed eigenvectors. All other columns of Z are set to zero."],
     "MINRGP"=>["[in]", "         MINRGP is REAL"],
     "RTOL1"=>["[in]", "         RTOL1 is REAL"],
     "RTOL2"=>
      ["[in]",
       "         RTOL2 is REAL",
       "          Parameters for bisection.",
       "          An interval [LEFT,RIGHT] has converged if",
       "          RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )"],
     "W"=>
      ["[in,out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements of W contain the APPROXIMATE eigenvalues for",
       "         which eigenvectors are to be computed.  The eigenvalues",
       "         should be grouped by split-off block and ordered from",
       "         smallest to largest within the block ( The output array",
       "         W from SLARRE is expected here ). Furthermore, they are with",
       "         respect to the shift of the corresponding root representation",
       "         for their block. On exit, W holds the eigenvalues of the",
       "         UNshifted matrix."],
     "WERR"=>
      ["[in,out]",
       "         WERR is REAL array, dimension (N)",
       "         The first M elements contain the semiwidth of the uncertainty",
       "         interval of the corresponding eigenvalue in W"],
     "WGAP"=>
      ["[in,out]",
       "         WGAP is REAL array, dimension (N)",
       "         The separation from the right neighbor eigenvalue in W."],
     "IBLOCK"=>
      ["[in]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         The indices of the blocks (submatrices) associated with the",
       "         corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue",
       "         W(i) belongs to the first block from the top, =2 if W(i)",
       "         belongs to the second block, etc."],
     "INDEXW"=>
      ["[in]",
       "         INDEXW is INTEGER array, dimension (N)",
       "         The indices of the eigenvalues within each block (submatrix);",
       "         for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the",
       "         i-th eigenvalue W(i) is the 10-th eigenvalue in the second block."],
     "GERS"=>
      ["[in]",
       "         GERS is REAL array, dimension (2*N)",
       "         The N Gerschgorin intervals (the i-th Gerschgorin interval",
       "         is (GERS(2*i-1), GERS(2*i)). The Gerschgorin intervals should",
       "         be computed from the original UNshifted matrix."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M) )",
       "         If INFO = 0, the first M columns of Z contain the",
       "         orthonormal eigenvectors of the matrix T",
       "         corresponding to the input eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The I-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*I-1 ) through",
       "         ISUPPZ( 2*I )."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (12*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (7*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         > 0:  A problem occurred in SLARRV.",
       "         < 0:  One of the called subroutines signaled an internal problem.",
       "               Needs inspection of the corresponding parameter IINFO",
       "               for further information.",
       "         =-1:  Problem in SLARRB when refining a child's eigenvalues.",
       "         =-2:  Problem in SLARRF when computing the RRR of a child.",
       "               When a child is inside a tight cluster, it can be difficult",
       "               to find an RRR. A partial remedy from the user's point of",
       "               view is to make the parameter MINRGP smaller and recompile.",
       "               However, as the orthogonality of the computed vectors is",
       "               proportional to 1/MINRGP, the user should be aware that",
       "               he might be trading in precision when he decreases MINRGP.",
       "         =-3:  Problem in SLARRB when refining a single eigenvalue",
       "               after the Rayleigh correction was rejected.",
       "         = 5:  The Rayleigh Quotient Iteration failed to converge to",
       "               full accuracy in MAXITR steps."]}},
 "cla_herfsx_extended"=>
  {"summary"=>
    ["CLA_HERFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by CHERFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by CHETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by CHETRF."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension",
       "                   (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by CHETRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is REAL array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by CLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is REAL array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is REAL array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]", "         AYB is REAL array, dimension (N)", "    Workspace."],
     "DY"=>
      ["[in]",
       "         DY is COMPLEX array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is COMPLEX array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is REAL",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is REAL",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to CLA_HERFSX_EXTENDED had an illegal",
       "            value"]}},
 "sormtr"=>
  {"summary"=>
    ["SORMTR overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "nq-1 elementary reflectors, as returned by SSYTRD:",
     "if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangle of A contains elementary reflectors",
       "                from SSYTRD;",
       "         = 'L': Lower triangle of A contains elementary reflectors",
       "                from SSYTRD."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension",
       "                              (LDA,M) if SIDE = 'L'",
       "                              (LDA,N) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by SSYTRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension",
       "                              (M-1) if SIDE = 'L'",
       "                              (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SSYTRD."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For optimum performance LWORK >= N*NB if SIDE = 'L', and",
       "         LWORK >= M*NB if SIDE = 'R', where NB is the optimal",
       "         blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dpbsv"=>
  {"summary"=>
    ["DPBSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite band matrix and X",
     "and B are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L * L**T,  if UPLO = 'L',",
     "where U is an upper triangular band matrix, and L is a lower",
     "triangular band matrix, with the same number of superdiagonals or",
     "subdiagonals as A.  The factored form of A is then used to solve the",
     "system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(KD+1+i-j,j) = A(i,j) for max(1,j-KD)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(N,j+KD).",
       "         See below for further details.",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**T*U or A = L*L**T of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "dlaswp"=>
  {"summary"=>
    ["DLASWP performs a series of row interchanges on the matrix A.",
     "One row interchange is initiated for each of rows K1 through K2 of A."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the matrix of column dimension N to which the row",
       "         interchanges will be applied.",
       "         On exit, the permuted matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A."],
     "K1"=>
      ["[in]",
       "         K1 is INTEGER",
       "         The first element of IPIV for which a row interchange will",
       "         be done."],
     "K2"=>
      ["[in]",
       "         K2 is INTEGER",
       "         (K2-K1+1) is the number of elements of IPIV for which a row",
       "         interchange will be done."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (K1+(K2-K1)*abs(INCX))",
       "         The vector of pivot indices. Only the elements in positions",
       "         K1 through K1+(K2-K1)*INCX of IPIV are accessed.",
       "         IPIV(K) = L implies rows K and L are to be interchanged."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of IPIV.  If IPIV",
       "         is negative, the pivots are applied in reverse order."]}},
 "dorgtr"=>
  {"summary"=>
    ["DORGTR generates a real orthogonal matrix Q which is defined as the",
     "product of n-1 elementary reflectors of order N, as returned by",
     "DSYTRD:",
     "if UPLO = 'U', Q = H(n-1) . . . H(2) H(1),",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(n-1)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangle of A contains elementary reflectors",
       "                from DSYTRD;",
       "         = 'L': Lower triangle of A contains elementary reflectors",
       "                from DSYTRD."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by DSYTRD.",
       "         On exit, the N-by-N orthogonal matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DSYTRD."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N-1).",
       "         For optimum performance LWORK >= (N-1)*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dsptri"=>
  {"summary"=>
    ["DSPTRI computes the inverse of a real symmetric indefinite matrix",
     "A in packed storage using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by DSPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by DSPTRF,",
       "         stored as a packed triangular matrix.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix, stored as a packed triangular matrix. The j-th column",
       "         of inv(A) is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;",
       "         if UPLO = 'L',",
       "            AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSPTRF."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "dsyevd"=>
  {"summary"=>
    ["DSYEVD computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric matrix A. If eigenvectors are desired, it uses a",
     "divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none.",
     "Because of large use of BLAS of level 3, DSYEVD needs N**2 more",
     "workspace than DSYEVX."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array,",
       "                                        dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be at least 2*N+1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least",
       "                                               1 + 6*N + 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i and JOBZ = 'N', then the algorithm failed",
       "               to converge; i off-diagonal elements of an intermediate",
       "               tridiagonal form did not converge to zero;",
       "               if INFO = i and JOBZ = 'V', then the algorithm failed",
       "               to compute an eigenvalue while working on the submatrix",
       "               lying in rows and columns INFO/(N+1) through",
       "               mod(INFO,N+1)."]}},
 "dptts2"=>
  {"summary"=>
    ["DPTTS2 solves a tridiagonal system of the form",
     "   A * X = B",
     "using the L*D*L**T factorization of A computed by DPTTRF.  D is a",
     "diagonal matrix specified in the vector D, L is a unit bidiagonal",
     "matrix whose subdiagonal is specified in the vector E, and X and B",
     "are N by NRHS matrices."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         L*D*L**T factorization of A."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the unit bidiagonal factor",
       "         L from the L*D*L**T factorization of A.  E can also be regarded",
       "         as the superdiagonal of the unit bidiagonal factor U from the",
       "         factorization A = U**T*D*U."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side vectors B for the system of",
       "         linear equations.",
       "         On exit, the solution vectors, X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."]}},
 "lsamen"=>
  {"summary"=>
    ["LSAMEN  tests if the first N letters of CA are the same as the",
     "first N letters of CB, regardless of case.",
     "LSAMEN returns .TRUE. if CA and CB are equivalent except for case",
     "and .FALSE. otherwise.  LSAMEN also returns .FALSE. if LEN( CA )",
     "or LEN( CB ) is less than N."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of characters in CA and CB to be compared."],
     "CA"=>["[in]", "         CA is CHARACTER*(*)"],
     "CB"=>
      ["[in]",
       "         CB is CHARACTER*(*)",
       "         CA and CB specify two character strings of length at least N.",
       "         Only the first N characters of each string will be accessed."]}},
 "ssterf"=>
  {"summary"=>
    ["SSTERF computes all eigenvalues of a symmetric tridiagonal matrix",
     "using the Pal-Walker-Kahan variant of the QL or QR algorithm."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix.",
       "         On exit, E has been destroyed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  the algorithm failed to find all of the eigenvalues in",
       "               a total of 30*N iterations; if INFO = i, then i",
       "               elements of E have not converged to zero."]}},
 "zgbtrf"=>
  {"summary"=>
    ["ZGBTRF computes an LU factorization of a complex m-by-n band matrix A",
     "using partial pivoting with row interchanges.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(kl+ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = +i, U(i,i) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "cgsvj1"=>
  {"summary"=>
    ["CGSVJ1 is called from CGESVJ as a pre-processor and that is its main",
     "purpose. It applies Jacobi rotations in the same way as CGESVJ does, but",
     "it targets only particular pivots and it does not check convergence",
     "(stopping criterion). Few tunning parameters (marked by [TP]) are",
     "available for the implementer.",
     "Further Details",
     "~~~~~~~~~~~~~~~",
     "CGSVJ1 applies few sweeps of Jacobi rotations in the column space of",
     "the input M-by-N matrix A. The pivot pairs are taken from the (1,2)",
     "off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The",
     "block-entries (tiles) of the (1,2) off-diagonal block are marked by the",
     "[x]'s in the following scheme:",
     "   | *  *  * [x] [x] [x]|",
     "   | *  *  * [x] [x] [x]|    Row-cycling in the nblr-by-nblc [x] blocks.",
     "   | *  *  * [x] [x] [x]|    Row-cyclic pivoting inside each [x] block.",
     "   |[x] [x] [x] *  *  * |",
     "   |[x] [x] [x] *  *  * |",
     "   |[x] [x] [x] *  *  * |",
     "In terms of the columns of A, the first N1 columns are rotated 'against'",
     "the remaining N-N1 columns, trying to increase the angle between the",
     "corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is",
     "tiled using quadratic tiles of side KBL. Here, KBL is a tunning parmeter.",
     "The number of sweeps is given in NSWEEP and the orthogonality threshold",
     "is given in TOL."],
   "param"=>
    {"JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether the output from this procedure is used",
       "         to compute the matrix V:",
       "         = 'V': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the N-by-N array V.",
       "               (See the description of V.)",
       "         = 'A': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the MV-by-N array V.",
       "               (See the descriptions of MV and V.)",
       "         = 'N': the Jacobi rotations are not accumulated."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         N1 specifies the 2 x 2 block partition, the first N1 columns are",
       "         rotated 'against' the remaining N-N1 columns of A."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, M-by-N matrix A, such that A*diag(D) represents",
       "         the input matrix.",
       "         On exit,",
       "         A_onexit * D_onexit represents the input matrix A*diag(D)",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of N1, D, TOL and NSWEEP.)"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX array, dimension (N)",
       "         The array D accumulates the scaling factors from the fast scaled",
       "         Jacobi rotations.",
       "         On entry, A*diag(D) represents the input matrix.",
       "         On exit, A_onexit*diag(D_onexit) represents the input matrix",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of N1, A, TOL and NSWEEP.)"],
     "SVA"=>
      ["[in,out]",
       "         SVA is REAL array, dimension (N)",
       "         On entry, SVA contains the Euclidean norms of the columns of",
       "         the matrix A*diag(D).",
       "         On exit, SVA contains the Euclidean norms of the columns of",
       "         the matrix onexit*diag(D_onexit)."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then MV is not referenced."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX array, dimension (LDV,N)",
       "         If JOBV .EQ. 'V' then N rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV .EQ. 'A' then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V', LDV .GE. N.",
       "         If JOBV = 'A', LDV .GE. MV."],
     "EPS"=>
      ["[in]", "         EPS is REAL", "         EPS = SLAMCH('Epsilon')"],
     "SFMIN"=>
      ["[in]",
       "         SFMIN is REAL",
       "         SFMIN = SLAMCH('Safe Minimum')"],
     "TOL"=>
      ["[in]",
       "         TOL is REAL",
       "         TOL is the threshold for Jacobi rotations. For a pair",
       "         A(:,p), A(:,q) of pivot columns, the Jacobi rotation is",
       "         applied only if ABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL."],
     "NSWEEP"=>
      ["[in]",
       "         NSWEEP is INTEGER",
       "         NSWEEP is the number of sweeps of Jacobi rotations to be",
       "         performed."],
     "WORK"=>["[out]", "        WORK is COMPLEX array, dimension LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         LWORK is the dimension of WORK. LWORK .GE. M."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value"]}},
 "dtpmlqt"=>
  {"summary"=>
    ["DTPMQRT applies a real orthogonal matrix Q obtained from a",
     "\"triangular-pentagonal\" real block reflector H to a general",
     "real matrix C, which consists of two blocks A and B."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size used for the storage of T.  K >= MB >= 1.",
       "         This must be the same value of MB used to generate T",
       "         in DTPLQT."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension (LDA,K)",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DTPLQT in B.  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDV >= max(1,M);",
       "         if SIDE = 'R', LDV >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by DTPLQT, stored as a MB-by-K matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension",
       "         (LDA,N) if SIDE = 'L' or",
       "         (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         Q*C or Q**T*C or C*Q or C*Q**T.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         Q*C or Q**T*C or C*Q or C*Q**T.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array. The dimension of WORK is",
       "          N*MB if SIDE = 'L', or  M*MB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ctrtrs"=>
  {"summary"=>
    ["CTRTRS solves a triangular system of the form",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B,",
     "where A is a triangular matrix of order N, and B is an N-by-NRHS",
     "matrix.  A check is made to verify that A is nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, the i-th diagonal element of A is zero,",
       "              indicating that the matrix is singular and the solutions",
       "              X have not been computed."]}},
 "spbstf"=>
  {"summary"=>
    ["SPBSTF computes a split Cholesky factorization of a real",
     "symmetric positive definite band matrix A.",
     "This routine is designed to be used in conjunction with SSBGST.",
     "The factorization has the form  A = S**T*S  where S is a band matrix",
     "of the same bandwidth as A and the following structure:",
     "  S = ( U    )",
     "      ( M  L )",
     "where U is upper triangular of order m = (n+kd)/2, and L is lower",
     "triangular of order n-m."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first kd+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the factor S from the split Cholesky",
       "         factorization A = S**T*S. See Further Details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, the factorization could not be completed,",
       "              because the updated element a(i,i) was negative; the",
       "              matrix A is not positive definite."]}},
 "ztbrfs"=>
  {"summary"=>
    ["ZTBRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular band",
     "coefficient matrix.",
     "The solution matrix X must be computed by ZTBTRS or some other",
     "means before entering this routine.  ZTBRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chegv"=>
  {"summary"=>
    ["CHEGV computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be Hermitian and B is also",
     "positive definite."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the Hermitian positive definite matrix B.",
       "         If UPLO = 'U', the leading N-by-N upper triangular part of B",
       "         contains the upper triangular part of the matrix B.",
       "         If UPLO = 'L', the leading N-by-N lower triangular part of B",
       "         contains the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,2*N-1).",
       "         For optimal efficiency, LWORK >= (NB+1)*N,",
       "         where NB is the blocksize for CHETRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is REAL array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  CPOTRF or CHEEV returned an error code:",
       "            <= N:  if INFO = i, CHEEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "slaed5"=>
  {"summary"=>
    ["This subroutine computes the I-th eigenvalue of a symmetric rank-one",
     "modification of a 2-by-2 diagonal matrix",
     "           diag( D )  +  RHO * Z * transpose(Z) .",
     "The diagonal elements in the array D are assumed to satisfy",
     "           D(i) < D(j)  for  i < j .",
     "We also assume RHO > 0 and that the Euclidean norm of the vector",
     "Z is one."],
   "param"=>
    {"I"=>
      ["[in]",
       "         I is INTEGER",
       "        The index of the eigenvalue to be computed.  I = 1 or I = 2."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (2)",
       "        The original eigenvalues.  We assume D(1) < D(2)."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension (2)",
       "        The components of the updating vector."],
     "DELTA"=>
      ["[out]",
       "         DELTA is REAL array, dimension (2)",
       "        The vector DELTA contains the information necessary",
       "        to construct the eigenvectors."],
     "RHO"=>
      ["[in]",
       "         RHO is REAL",
       "        The scalar in the symmetric updating formula."],
     "DLAM"=>
      ["[out]",
       "         DLAM is REAL",
       "        The computed lambda_I, the I-th updated eigenvalue."]}},
 "clahr2"=>
  {"summary"=>
    ["CLAHR2 reduces the first NB columns of A complex general n-BY-(n-k+1)",
     "matrix A so that elements below the k-th subdiagonal are zero. The",
     "reduction is performed by an unitary similarity transformation",
     "Q**H * A * Q. The routine returns the matrices V and T which determine",
     "Q as a block reflector I - V*T*v**H, and also the matrix Y = A * V * T.",
     "This is an auxiliary routine called by CGEHRD."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The offset for the reduction. Elements below the k-th",
       "         subdiagonal in the first NB columns are reduced to zero.",
       "         K < N."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of columns to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N-K+1)",
       "         On entry, the n-by-(n-k+1) general matrix A.",
       "         On exit, the elements on and above the k-th subdiagonal in",
       "         the first NB columns are overwritten with the corresponding",
       "         elements of the reduced matrix; the elements below the k-th",
       "         subdiagonal, with the array TAU, represent the matrix Q as a",
       "         product of elementary reflectors. The other columns of A are",
       "         unchanged. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (NB)",
       "         The scalar factors of the elementary reflectors. See Further",
       "         Details."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,NB)",
       "         The upper triangular matrix T."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "Y"=>
      ["[out]",
       "         Y is COMPLEX array, dimension (LDY,NB)",
       "         The n-by-nb matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "         The leading dimension of the array Y. LDY >= N."]}},
 "dgghrd"=>
  {"summary"=>
    ["DGGHRD reduces a pair of real matrices (A,B) to generalized upper",
     "Hessenberg form using orthogonal transformations, where A is a",
     "general matrix and B is upper triangular.  The form of the",
     "generalized eigenvalue problem is",
     "   A*x = lambda*B*x,",
     "and B is typically made upper triangular by computing its QR",
     "factorization and moving the orthogonal matrix Q to the left side",
     "of the equation.",
     "This subroutine simultaneously reduces A to a Hessenberg matrix H:",
     "   Q**T*A*Z = H",
     "and transforms B to another upper triangular matrix T:",
     "   Q**T*B*Z = T",
     "in order to reduce the problem to its standard form",
     "   H*y = lambda*T*y",
     "where y = Z**T*x.",
     "The orthogonal matrices Q and Z are determined as products of Givens",
     "rotations.  They may either be formed explicitly, or they may be",
     "postmultiplied into input matrices Q1 and Z1, so that",
     "     Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T",
     "     Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T",
     "If Q1 is the orthogonal matrix from the QR factorization of B in the",
     "original equation A*x = lambda*B*x, then DGGHRD reduces the original",
     "problem to generalized Hessenberg form."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': do not compute Q;",
       "         = 'I': Q is initialized to the unit matrix, and the",
       "                orthogonal matrix Q is returned;",
       "         = 'V': Q must contain an orthogonal matrix Q1 on entry,",
       "                and the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': do not compute Z;",
       "         = 'I': Z is initialized to the unit matrix, and the",
       "                orthogonal matrix Z is returned;",
       "         = 'V': Z must contain an orthogonal matrix Z1 on entry,",
       "                and the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of A which are to be",
       "         reduced.  It is assumed that A is already upper triangular",
       "         in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are",
       "         normally set by a previous call to DGGBAL; otherwise they",
       "         should be set to 1 and N respectively.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         rest is set to zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the N-by-N upper triangular matrix B.",
       "         On exit, the upper triangular matrix T = Q**T B Z.  The",
       "         elements below the diagonal are set to zero."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the orthogonal matrix Q1,",
       "         typically from the QR factorization of B.",
       "         On exit, if COMPQ='I', the orthogonal matrix Q, and if",
       "         COMPQ = 'V', the product Q1*Q.",
       "         Not referenced if COMPQ='N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the orthogonal matrix Z1.",
       "         On exit, if COMPZ='I', the orthogonal matrix Z, and if",
       "         COMPZ = 'V', the product Z1*Z.",
       "         Not referenced if COMPZ='N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.",
       "         LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zptts2"=>
  {"summary"=>
    ["ZPTTS2 solves a tridiagonal system of the form",
     "   A * X = B",
     "using the factorization A = U**H *D*U or A = L*D*L**H computed by ZPTTRF.",
     "D is a diagonal matrix specified in the vector D, U (or L) is a unit",
     "bidiagonal matrix whose superdiagonal (subdiagonal) is specified in",
     "the vector E, and X and B are N by NRHS matrices."],
   "param"=>
    {"IUPLO"=>
      ["[in]",
       "         IUPLO is INTEGER",
       "         Specifies the form of the factorization and whether the",
       "         vector E is the superdiagonal of the upper bidiagonal factor",
       "         U or the subdiagonal of the lower bidiagonal factor L.",
       "         = 1:  A = U**H *D*U, E is the superdiagonal of U",
       "         = 0:  A = L*D*L**H, E is the subdiagonal of L"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         factorization A = U**H *D*U or A = L*D*L**H."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N-1)",
       "         If IUPLO = 1, the (n-1) superdiagonal elements of the unit",
       "         bidiagonal factor U from the factorization A = U**H*D*U.",
       "         If IUPLO = 0, the (n-1) subdiagonal elements of the unit",
       "         bidiagonal factor L from the factorization A = L*D*L**H."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side vectors B for the system of",
       "         linear equations.",
       "         On exit, the solution vectors, X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."]}},
 "slaqr4"=>
  {"summary"=>
    ["   SLAQR4 implements one level of recursion for SLAQR0.",
     "   It is a complete implementation of the small bulge multi-shift",
     "   QR algorithm.  It may be called by SLAQR0 and, for large enough",
     "   deflation window size, it may be called by SLAQR3.  This",
     "   subroutine is identical to SLAQR0 except that it calls SLAQR2",
     "   instead of SLAQR3.",
     "   SLAQR4 computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**T, where T is an upper quasi-triangular matrix (the",
     "   Schur form), and Z is the orthogonal matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input orthogonal",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the orthogonal matrix Q:  A = Q*H*Q**T = (QZ)*T*(QZ)**T."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N and, if ILO.GT.1,",
       "          H(ILO,ILO-1) is zero. ILO and IHI are normally set by a",
       "          previous call to SGEBAL, and then passed to SGEHRD when the",
       "          matrix output by SGEBAL is reduced to Hessenberg form.",
       "          Otherwise, ILO and IHI should be set to 1 and N,",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is REAL array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and WANTT is .TRUE., then H contains",
       "          the upper quasi-triangular matrix T from the Schur",
       "          decomposition (the Schur form); 2-by-2 diagonal blocks",
       "          (corresponding to complex conjugate pairs of eigenvalues)",
       "          are returned in standard form, with H(i,i) = H(i+1,i+1)",
       "          and H(i+1,i)*H(i,i+1).LT.0. If INFO = 0 and WANTT is",
       "          .FALSE., then the contents of H are unspecified on exit.",
       "          (The output value of H when INFO.GT.0 is given under the",
       "          description of INFO below.)",
       "          This subroutine may explicitly set H(i,j) = 0 for i.GT.j and",
       "          j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "WR"=>["[out]", "         WR is REAL array, dimension (IHI)"],
     "WI"=>
      ["[out]",
       "         WI is REAL array, dimension (IHI)",
       "          The real and imaginary parts, respectively, of the computed",
       "          eigenvalues of H(ILO:IHI,ILO:IHI) are stored in WR(ILO:IHI)",
       "          and WI(ILO:IHI). If two eigenvalues are computed as a",
       "          complex conjugate pair, they are stored in consecutive",
       "          elements of WR and WI, say the i-th and (i+1)th, with",
       "          WI(i) .GT. 0 and WI(i+1) .LT. 0. If WANTT is .TRUE., then",
       "          the eigenvalues are stored in the same order as on the",
       "          diagonal of the Schur form returned in H, with",
       "          WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2 diagonal",
       "          block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and",
       "          WI(i+1) = -WI(i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "          Specify the rows of Z to which transformations must be",
       "          applied if WANTZ is .TRUE..",
       "          1 .LE. ILOZ .LE. ILO; IHI .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ,IHI)",
       "          If WANTZ is .FALSE., then Z is not referenced.",
       "          If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is",
       "          replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the",
       "          orthogonal Schur factor of H(ILO:IHI,ILO:IHI).",
       "          (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if WANTZ is .TRUE.",
       "          then LDZ.GE.MAX(1,IHIZ).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension LWORK",
       "          On exit, if LWORK = -1, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient, but LWORK typically as large as 6*N may",
       "          be required for optimal performance.  A workspace query",
       "          to determine the optimal workspace size is recommended.",
       "          If LWORK = -1, then SLAQR4 does a workspace query.",
       "          In this case, SLAQR4 checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .GT. 0:  if INFO = i, SLAQR4 failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and WANT is .FALSE., then on exit,",
       "               the remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is a orthogonal matrix.  The final",
       "               value of  H is upper Hessenberg and triangular in",
       "               rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                 (final value of Z(ILO:IHI,ILOZ:IHIZ)",
       "                  =  (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U",
       "               where U is the orthogonal matrix in (*) (regard-",
       "               less of the value of WANTT.)",
       "               If INFO .GT. 0 and WANTZ is .FALSE., then Z is not",
       "               accessed."]}},
 "slassq"=>
  {"summary"=>
    ["SLASSQ  returns the values  scl  and  smsq  such that",
     "   ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq,",
     "where  x( i ) = X( 1 + ( i - 1 )*INCX ). The value of  sumsq  is",
     "assumed to be non-negative and  scl  returns the value",
     "   scl = max( scale, abs( x( i ) ) ).",
     "scale and sumsq must be supplied in SCALE and SUMSQ and",
     "scl and smsq are overwritten on SCALE and SUMSQ respectively.",
     "The routine makes only one pass through the vector x."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements to be used from the vector X."],
     "X"=>
      ["[in]",
       "         X is REAL array, dimension (N)",
       "         The vector for which a scaled sum of squares is computed.",
       "            x( i )  = X( 1 + ( i - 1 )*INCX ), 1 <= i <= n."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of the vector X.",
       "         INCX > 0."],
     "SCALE"=>
      ["[in,out]",
       "         SCALE is REAL",
       "         On entry, the value  scale  in the equation above.",
       "         On exit, SCALE is overwritten with  scl , the scaling factor",
       "         for the sum of squares."],
     "SUMSQ"=>
      ["[in,out]",
       "         SUMSQ is REAL",
       "         On entry, the value  sumsq  in the equation above.",
       "         On exit, SUMSQ is overwritten with  smsq , the basic sum of",
       "         squares from which  scl  has been factored out."]}},
 "dlasd3"=>
  {"summary"=>
    ["DLASD3 finds all the square roots of the roots of the secular",
     "equation, as defined by the values in D and Z.  It makes the",
     "appropriate calls to DLASD4 and then updates the singular",
     "vectors by matrix multiplication.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none.",
     "DLASD3 is called from DLASD1."],
   "param"=>
    {"NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block.  NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block.  NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has N = NL + NR + 1 rows and",
       "        M = N + SQRE >= N columns."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "        The size of the secular equation, 1 =< K = < N."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension(K)",
       "        On exit the square roots of the roots of the secular equation,",
       "        in ascending order."],
     "Q"=>
      ["[out]",
       "         Q is DOUBLE PRECISION array,",
       "                    dimension at least (LDQ,K)."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= K."],
     "DSIGMA"=>
      ["[in]",
       "         DSIGMA is DOUBLE PRECISION array, dimension(K)",
       "        The first K elements of this array contain the old roots",
       "        of the deflated updating problem.  These are the poles",
       "        of the secular equation."],
     "U"=>
      ["[out]",
       "         U is DOUBLE PRECISION array, dimension (LDU, N)",
       "        The last N - K columns of this matrix contain the deflated",
       "        left singular vectors."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "        The leading dimension of the array U.  LDU >= N."],
     "U2"=>
      ["[in,out]",
       "         U2 is DOUBLE PRECISION array, dimension (LDU2, N)",
       "        The first K columns of this matrix contain the non-deflated",
       "        left singular vectors for the split problem."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "        The leading dimension of the array U2.  LDU2 >= N."],
     "VT"=>
      ["[out]",
       "         VT is DOUBLE PRECISION array, dimension (LDVT, M)",
       "        The last M - K columns of VT**T contain the deflated",
       "        right singular vectors."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "        The leading dimension of the array VT.  LDVT >= N."],
     "VT2"=>
      ["[in,out]",
       "         VT2 is DOUBLE PRECISION array, dimension (LDVT2, N)",
       "        The first K columns of VT2**T contain the non-deflated",
       "        right singular vectors for the split problem."],
     "LDVT2"=>
      ["[in]",
       "         LDVT2 is INTEGER",
       "        The leading dimension of the array VT2.  LDVT2 >= N."],
     "IDXC"=>
      ["[in]",
       "         IDXC is INTEGER array, dimension ( N )",
       "        The permutation used to arrange the columns of U (and rows of",
       "        VT) into three groups:  the first group contains non-zero",
       "        entries only at and above (or before) NL +1; the second",
       "        contains non-zero entries only at and below (or after) NL+2;",
       "        and the third is dense. The first column of U and the row of",
       "        VT are treated separately, however.",
       "        The rows of the singular vectors found by DLASD4",
       "        must be likewise permuted before the matrix multiplies can",
       "        take place."],
     "CTOT"=>
      ["[in]",
       "         CTOT is INTEGER array, dimension ( 4 )",
       "        A count of the total number of the various types of columns",
       "        in U (or rows in VT), as described in IDXC. The fourth column",
       "        type is any column which has been deflated."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension (K)",
       "        The first K elements of this array contain the components",
       "        of the deflation-adjusted updating row vector."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit.",
       "        < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "        > 0:  if INFO = 1, a singular value did not converge"]}},
 "dgesdd"=>
  {"summary"=>
    ["DGESDD computes the singular value decomposition (SVD) of a real",
     "M-by-N matrix A, optionally computing the left and right singular",
     "vectors.  If singular vectors are desired, it uses a",
     "divide-and-conquer algorithm.",
     "The SVD is written",
     "     A = U * SIGMA * transpose(V)",
     "where SIGMA is an M-by-N matrix which is zero except for its",
     "min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and",
     "V is an N-by-N orthogonal matrix.  The diagonal elements of SIGMA",
     "are the singular values of A; they are real and non-negative, and",
     "are returned in descending order.  The first min(m,n) columns of",
     "U and V are the left and right singular vectors of A.",
     "Note that the routine returns VT = V**T, not V.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'A':  all M columns of U and all N rows of V**T are",
       "                 returned in the arrays U and VT;",
       "         = 'S':  the first min(M,N) columns of U and the first",
       "                 min(M,N) rows of V**T are returned in the arrays U",
       "                 and VT;",
       "         = 'O':  If M >= N, the first N columns of U are overwritten",
       "                 on the array A and all rows of V**T are returned in",
       "                 the array VT;",
       "                 otherwise, all columns of U are returned in the",
       "                 array U and the first M rows of V**T are overwritten",
       "                 in the array A;",
       "         = 'N':  no columns of U or rows of V**T are computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if JOBZ = 'O',  A is overwritten with the first N columns",
       "                         of U (the left singular vectors, stored",
       "                         columnwise) if M >= N;",
       "                         A is overwritten with the first M rows",
       "                         of V**T (the right singular vectors, stored",
       "                         rowwise) otherwise.",
       "         if JOBZ .ne. 'O', the contents of A are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is DOUBLE PRECISION array, dimension (LDU,UCOL)",
       "         UCOL = M if JOBZ = 'A' or JOBZ = 'O' and M < N;",
       "         UCOL = min(M,N) if JOBZ = 'S'.",
       "         If JOBZ = 'A' or JOBZ = 'O' and M < N, U contains the M-by-M",
       "         orthogonal matrix U;",
       "         if JOBZ = 'S', U contains the first min(M,N) columns of U",
       "         (the left singular vectors, stored columnwise);",
       "         if JOBZ = 'O' and M >= N, or JOBZ = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1; if",
       "         JOBZ = 'S' or 'A' or JOBZ = 'O' and M < N, LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is DOUBLE PRECISION array, dimension (LDVT,N)",
       "         If JOBZ = 'A' or JOBZ = 'O' and M >= N, VT contains the",
       "         N-by-N orthogonal matrix V**T;",
       "         if JOBZ = 'S', VT contains the first min(M,N) rows of",
       "         V**T (the right singular vectors, stored rowwise);",
       "         if JOBZ = 'O' and M < N, or JOBZ = 'N', VT is not referenced."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1;",
       "         if JOBZ = 'A' or JOBZ = 'O' and M >= N, LDVT >= N;",
       "         if JOBZ = 'S', LDVT >= min(M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK;"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= 1.",
       "         If LWORK = -1, a workspace query is assumed.  The optimal",
       "         size for the WORK array is calculated and stored in WORK(1),",
       "         and no other work except argument checking is performed.",
       "         Let mx = max(M,N) and mn = min(M,N).",
       "         If JOBZ = 'N', LWORK >= 3*mn + max( mx, 7*mn ).",
       "         If JOBZ = 'O', LWORK >= 3*mn + max( mx, 5*mn*mn + 4*mn ).",
       "         If JOBZ = 'S', LWORK >= 4*mn*mn + 7*mn.",
       "         If JOBZ = 'A', LWORK >= 4*mn*mn + 6*mn + mx.",
       "         These are not tight minimums in all cases; see comments inside code.",
       "         For good performance, LWORK should generally be larger;",
       "         a query is recommended."],
     "IWORK"=>
      ["[out]", "         IWORK is INTEGER array, dimension (8*min(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  DBDSDC did not converge, updating process failed."]}},
 "dspev"=>
  {"summary"=>
    ["DSPEV computes all the eigenvalues and, optionally, eigenvectors of a",
     "real symmetric matrix A in packed storage."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "spotrf2"=>
  {"summary"=>
    ["SPOTRF2 computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A using the recursive algorithm.",
     "The factorization has the form",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the recursive version of the algorithm. It divides",
     "the matrix into four submatrices:",
     "       [  A11 | A12  ]  where A11 is n1 by n1 and A22 is n2 by n2",
     "   A = [ -----|----- ]  with n1 = n/2",
     "       [  A21 | A22  ]       n2 = n-n1",
     "The subroutine calls itself to factor A11. Update and scale A21",
     "or A12, update A22 then call itself to factor A22."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "sggev"=>
  {"summary"=>
    ["SGGEV computes for a pair of N-by-N real nonsymmetric matrices (A,B)",
     "the generalized eigenvalues, and optionally, the left and/or right",
     "generalized eigenvectors.",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right eigenvector v(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 A * v(j) = lambda(j) * B * v(j).",
     "The left eigenvector u(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 u(j)**H * A  = lambda(j) * u(j)**H * B .",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHAR"=>["[out]", "         ALPHAR is REAL array, dimension (N)"],
     "ALPHAI"=>["[out]", "         ALPHAI is REAL array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  If ALPHAI(j) is zero, then",
       "         the j-th eigenvalue is real; if positive, then the j-th and",
       "         (j+1)-st eigenvalues are a complex conjugate pair, with",
       "         ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio",
       "         alpha/beta.  However, ALPHAR and ALPHAI will be always less",
       "         than and usually comparable with norm(A) in magnitude, and",
       "         BETA always less than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is REAL array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         u(j) = VL(:,j), the j-th column of VL. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         u(j) = VL(:,j)+i*VL(:,j+1) and u(j+1) = VL(:,j)-i*VL(:,j+1).",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part)+abs(imag. part)=1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is REAL array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         v(j) = VR(:,j), the j-th column of VR. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1).",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part)+abs(imag. part)=1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,8*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHAR(j), ALPHAI(j), and BETA(j)",
       "               should be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in SHGEQZ.",
       "               =N+2: error return from STGEVC."]}},
 "zhetrf_rk"=>
  {"summary"=>
    ["ZHETRF_RK computes the factorization of a complex Hermitian matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the Hermitian block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension ( MAX(1,LWORK) ).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned",
       "         by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array, returns this value as the first entry of the WORK",
       "         array, and no error message related to LWORK is issued",
       "         by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "ssteqr"=>
  {"summary"=>
    ["SSTEQR computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric tridiagonal matrix using the implicit QL or QR method.",
     "The eigenvectors of a full or band symmetric matrix can also be found",
     "if SSYTRD or SSPTRD or SSBTRD has been used to reduce this matrix to",
     "tridiagonal form."],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'V':  Compute eigenvalues and eigenvectors of the original",
       "                 symmetric matrix.  On entry, Z must contain the",
       "                 orthogonal matrix used to reduce the original matrix",
       "                 to tridiagonal form.",
       "         = 'I':  Compute eigenvalues and eigenvectors of the",
       "                 tridiagonal matrix.  Z is initialized to the identity",
       "                 matrix."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the diagonal elements of the tridiagonal matrix.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         On entry, if  COMPZ = 'V', then Z contains the orthogonal",
       "         matrix used in the reduction to tridiagonal form.",
       "         On exit, if INFO = 0, then if  COMPZ = 'V', Z contains the",
       "         orthonormal eigenvectors of the original symmetric matrix,",
       "         and if COMPZ = 'I', Z contains the orthonormal eigenvectors",
       "         of the symmetric tridiagonal matrix.",
       "         If COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         eigenvectors are desired, then  LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (max(1,2*N-2))",
       "         If COMPZ = 'N', then WORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  the algorithm has failed to find all the eigenvalues in",
       "               a total of 30*N iterations; if INFO = i, then i",
       "               elements of E have not converged to zero; on exit, D",
       "               and E contain the elements of a symmetric tridiagonal",
       "               matrix which is orthogonally similar to the original",
       "               matrix."]}},
 "dlaqp2"=>
  {"summary"=>
    ["DLAQP2 computes a QR factorization with column pivoting of",
     "the block A(OFFSET+1:M,1:N).",
     "The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0."],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         The number of rows of the matrix A that must be pivoted",
       "         but no factorized. OFFSET >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the upper triangle of block A(OFFSET+1:M,1:N) is",
       "         the triangular factor obtained; the elements in block",
       "         A(OFFSET+1:M,1:N) below the diagonal, together with the",
       "         array TAU, represent the orthogonal matrix Q as a product of",
       "         elementary reflectors. Block A(1:OFFSET,1:N) has been",
       "         accordingly pivoted, but no factorized."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(i) .ne. 0, the i-th column of A is permuted",
       "         to the front of A*P (a leading column); if JPVT(i) = 0,",
       "         the i-th column of A is a free column.",
       "         On exit, if JPVT(i) = k, then the i-th column of A*P",
       "         was the k-th column of A."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors."],
     "VN1"=>
      ["[in,out]",
       "         VN1 is DOUBLE PRECISION array, dimension (N)",
       "         The vector with the partial column norms."],
     "VN2"=>
      ["[in,out]",
       "         VN2 is DOUBLE PRECISION array, dimension (N)",
       "         The vector with the exact column norms."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"]}},
 "stgsna"=>
  {"summary"=>
    ["STGSNA estimates reciprocal condition numbers for specified",
     "eigenvalues and/or eigenvectors of a matrix pair (A, B) in",
     "generalized real Schur canonical form (or of any matrix pair",
     "(Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where",
     "Z**T denotes the transpose of Z.",
     "(A, B) must be in generalized real Schur form (as returned by SGGES),",
     "i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal",
     "blocks. B is upper triangular."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for",
       "         eigenvalues (S) or eigenvectors (DIF):",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for eigenvectors only (DIF);",
       "         = 'B': for both eigenvalues and eigenvectors (S and DIF)."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute condition numbers for all eigenpairs;",
       "         = 'S': compute condition numbers for selected eigenpairs",
       "                specified by the array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenpairs for which",
       "         condition numbers are required. To select condition numbers",
       "         for the eigenpair corresponding to a real eigenvalue w(j),",
       "         SELECT(j) must be set to .TRUE.. To select condition numbers",
       "         corresponding to a complex conjugate pair of eigenvalues w(j)",
       "         and w(j+1), either SELECT(j) or SELECT(j+1) or both, must be",
       "         set to .TRUE..",
       "         If HOWMNY = 'A', SELECT is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the square matrix pair (A, B). N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The upper quasi-triangular matrix A in the pair (A,B)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,N)",
       "         The upper triangular matrix B in the pair (A,B)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL array, dimension (LDVL,M)",
       "         If JOB = 'E' or 'B', VL must contain left eigenvectors of",
       "         (A, B), corresponding to the eigenpairs specified by HOWMNY",
       "         and SELECT. The eigenvectors must be stored in consecutive",
       "         columns of VL, as returned by STGEVC.",
       "         If JOB = 'V', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL. LDVL >= 1.",
       "         If JOB = 'E' or 'B', LDVL >= N."],
     "VR"=>
      ["[in]",
       "         VR is REAL array, dimension (LDVR,M)",
       "         If JOB = 'E' or 'B', VR must contain right eigenvectors of",
       "         (A, B), corresponding to the eigenpairs specified by HOWMNY",
       "         and SELECT. The eigenvectors must be stored in consecutive",
       "         columns ov VR, as returned by STGEVC.",
       "         If JOB = 'V', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR. LDVR >= 1.",
       "         If JOB = 'E' or 'B', LDVR >= N."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (MM)",
       "         If JOB = 'E' or 'B', the reciprocal condition numbers of the",
       "         selected eigenvalues, stored in consecutive elements of the",
       "         array. For a complex conjugate pair of eigenvalues two",
       "         consecutive elements of S are set to the same value. Thus",
       "         S(j), DIF(j), and the j-th columns of VL and VR all",
       "         correspond to the same eigenpair (but not in general the",
       "         j-th eigenpair, unless all eigenpairs are selected).",
       "         If JOB = 'V', S is not referenced."],
     "DIF"=>
      ["[out]",
       "         DIF is REAL array, dimension (MM)",
       "         If JOB = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the selected eigenvectors, stored in consecutive",
       "         elements of the array. For a complex eigenvector two",
       "         consecutive elements of DIF are set to the same value. If",
       "         the eigenvalues cannot be reordered to compute DIF(j), DIF(j)",
       "         is set to 0; this can only occur when the true value would be",
       "         very small anyway.",
       "         If JOB = 'E', DIF is not referenced."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of elements in the arrays S and DIF. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of elements of the arrays S and DIF used to store",
       "         the specified condition numbers; for each selected real",
       "         eigenvalue one element is used, and for each selected complex",
       "         conjugate pair of eigenvalues, two elements are used.",
       "         If HOWMNY = 'A', M is set to N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         If JOB = 'V' or 'B' LWORK >= 2*N*(N+2)+16.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N + 6)",
       "         If JOB = 'E', IWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         =0: Successful exit",
       "         <0: If INFO = -i, the i-th argument had an illegal value"]}},
 "zunmtr"=>
  {"summary"=>
    ["ZUNMTR overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "nq-1 elementary reflectors, as returned by ZHETRD:",
     "if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangle of A contains elementary reflectors",
       "                from ZHETRD;",
       "         = 'L': Lower triangle of A contains elementary reflectors",
       "                from ZHETRD."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension",
       "                              (LDA,M) if SIDE = 'L'",
       "                              (LDA,N) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by ZHETRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension",
       "                              (M-1) if SIDE = 'L'",
       "                              (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZHETRD."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For optimum performance LWORK >= N*NB if SIDE = 'L', and",
       "         LWORK >=M*NB if SIDE = 'R', where NB is the optimal",
       "         blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgesvj"=>
  {"summary"=>
    ["SGESVJ computes the singular value decomposition (SVD) of a real",
     "M-by-N matrix A, where M >= N. The SVD of A is written as",
     "                                   [++]   [xx]   [x0]   [xx]",
     "             A = U * SIGMA * V^t,  [++] = [xx] * [ox] * [xx]",
     "                                   [++]   [xx]",
     "where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal",
     "matrix, and V is an N-by-N orthogonal matrix. The diagonal elements",
     "of SIGMA are the singular values of A. The columns of U and V are the",
     "left and the right singular vectors of A, respectively.",
     "SGESVJ can sometimes compute tiny singular values and their singular vectors much",
     "more accurately than other SVD routines, see below under Further Details."],
   "param"=>
    {"JOBA"=>
      ["[in]",
       "         JOBA is CHARACTER* 1",
       "         Specifies the structure of A.",
       "         = 'L': The input matrix A is lower triangular;",
       "         = 'U': The input matrix A is upper triangular;",
       "         = 'G': The input matrix A is general M-by-N matrix, M >= N."],
     "JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies whether to compute the left singular vectors",
       "         (columns of U):",
       "         = 'U': The left singular vectors corresponding to the nonzero",
       "                singular values are computed and returned in the leading",
       "                columns of A. See more details in the description of A.",
       "                The default numerical orthogonality threshold is set to",
       "                approximately TOL=CTOL*EPS, CTOL=SQRT(M), EPS=SLAMCH('E').",
       "         = 'C': Analogous to JOBU='U', except that user can control the",
       "                level of numerical orthogonality of the computed left",
       "                singular vectors. TOL can be set to TOL = CTOL*EPS, where",
       "                CTOL is given on input in the array WORK.",
       "                No CTOL smaller than ONE is allowed. CTOL greater",
       "                than 1 / EPS is meaningless. The option 'C'",
       "                can be used if M*EPS is satisfactory orthogonality",
       "                of the computed left singular vectors, so CTOL=M could",
       "                save few sweeps of Jacobi rotations.",
       "                See the descriptions of A and WORK(1).",
       "         = 'N': The matrix U is not computed. However, see the",
       "                description of A."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether to compute the right singular vectors, that",
       "         is, the matrix V:",
       "         = 'V' : the matrix V is computed and returned in the array V",
       "         = 'A' : the Jacobi rotations are applied to the MV-by-N",
       "                 array V. In other words, the right singular vector",
       "                 matrix V is not computed explicitly; instead it is",
       "                 applied to an MV-by-N matrix initially stored in the",
       "                 first MV rows of V.",
       "         = 'N' : the matrix V is not computed and the array V is not",
       "                 referenced"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A. 1/SLAMCH('E') > M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         If JOBU .EQ. 'U' .OR. JOBU .EQ. 'C':",
       "                If INFO .EQ. 0 :",
       "                RANKA orthonormal columns of U are returned in the",
       "                leading RANKA columns of the array A. Here RANKA <= N",
       "                is the number of computed singular values of A that are",
       "                above the underflow threshold SLAMCH('S'). The singular",
       "                vectors corresponding to underflowed or zero singular",
       "                values are not computed. The value of RANKA is returned",
       "                in the array WORK as RANKA=NINT(WORK(2)). Also see the",
       "                descriptions of SVA and WORK. The computed columns of U",
       "                are mutually numerically orthogonal up to approximately",
       "                TOL=SQRT(M)*EPS (default); or TOL=CTOL*EPS (JOBU.EQ.'C'),",
       "                see the description of JOBU.",
       "                If INFO .GT. 0,",
       "                the procedure SGESVJ did not converge in the given number",
       "                of iterations (sweeps). In that case, the computed",
       "                columns of U may not be orthogonal up to TOL. The output",
       "                U (stored in A), SIGMA (given by the computed singular",
       "                values in SVA(1:N)) and V is still a decomposition of the",
       "                input matrix A in the sense that the residual",
       "                ||A-SCALE*U*SIGMA*V^T||_2 / ||A||_2 is small.",
       "         If JOBU .EQ. 'N':",
       "                If INFO .EQ. 0 :",
       "                Note that the left singular vectors are 'for free' in the",
       "                one-sided Jacobi SVD algorithm. However, if only the",
       "                singular values are needed, the level of numerical",
       "                orthogonality of U is not an issue and iterations are",
       "                stopped when the columns of the iterated matrix are",
       "                numerically orthogonal up to approximately M*EPS. Thus,",
       "                on exit, A contains the columns of U scaled with the",
       "                corresponding singular values.",
       "                If INFO .GT. 0 :",
       "                the procedure SGESVJ did not converge in the given number",
       "                of iterations (sweeps)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "SVA"=>
      ["[out]",
       "         SVA is REAL array, dimension (N)",
       "         On exit,",
       "         If INFO .EQ. 0 :",
       "         depending on the value SCALE = WORK(1), we have:",
       "                If SCALE .EQ. ONE:",
       "                SVA(1:N) contains the computed singular values of A.",
       "                During the computation SVA contains the Euclidean column",
       "                norms of the iterated matrices in the array A.",
       "                If SCALE .NE. ONE:",
       "                The singular values of A are SCALE*SVA(1:N), and this",
       "                factored representation is due to the fact that some of the",
       "                singular values of A might underflow or overflow.",
       "         If INFO .GT. 0 :",
       "         the procedure SGESVJ did not converge in the given number of",
       "         iterations (sweeps) and SCALE*SVA(1:N) may not be accurate."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then the product of Jacobi rotations in SGESVJ",
       "         is applied to the first MV rows of V. See the description of JOBV."],
     "V"=>
      ["[in,out]",
       "         V is REAL array, dimension (LDV,N)",
       "         If JOBV = 'V', then V contains on exit the N-by-N matrix of",
       "                        the right singular vectors;",
       "         If JOBV = 'A', then V contains the product of the computed right",
       "                        singular vector matrix and the initial matrix in",
       "                        the array V.",
       "         If JOBV = 'N', then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V, LDV .GE. 1.",
       "         If JOBV .EQ. 'V', then LDV .GE. max(1,N).",
       "         If JOBV .EQ. 'A', then LDV .GE. max(1,MV) ."],
     "WORK"=>
      ["[in,out]",
       "         WORK is REAL array, dimension MAX(6,M+N).",
       "         On entry,",
       "         If JOBU .EQ. 'C' :",
       "         WORK(1) = CTOL, where CTOL defines the threshold for convergence.",
       "                   The process stops if all columns of A are mutually",
       "                   orthogonal up to CTOL*EPS, EPS=SLAMCH('E').",
       "                   It is required that CTOL >= ONE, i.e. it is not",
       "                   allowed to force the routine to obtain orthogonality",
       "                   below EPSILON.",
       "         On exit,",
       "         WORK(1) = SCALE is the scaling factor such that SCALE*SVA(1:N)",
       "                   are the computed singular vcalues of A.",
       "                   (See description of SVA().)",
       "         WORK(2) = NINT(WORK(2)) is the number of the computed nonzero",
       "                   singular values.",
       "         WORK(3) = NINT(WORK(3)) is the number of the computed singular",
       "                   values that are larger than the underflow threshold.",
       "         WORK(4) = NINT(WORK(4)) is the number of sweeps of Jacobi",
       "                   rotations needed for numerical convergence.",
       "         WORK(5) = max_{i.NE.j} |COS(A(:,i),A(:,j))| in the last sweep.",
       "                   This is useful information in cases when SGESVJ did",
       "                   not converge, as it can be used to estimate whether",
       "                   the output is stil useful and for post festum analysis.",
       "         WORK(6) = the largest absolute value over all sines of the",
       "                   Jacobi rotation angles in the last sweep. It can be",
       "                   useful for a post festum analysis."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "        length of WORK, WORK >= MAX(6,M+N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value",
       "         > 0 : SGESVJ did not converge in the maximal allowed number (30)",
       "               of sweeps. The output may still be useful. See the",
       "               description of WORK."]}},
 "zsyconv"=>
  {"summary"=>
    ["ZSYCONV converts A given by ZHETRF into L and D or vice-versa.",
     "Get nondiagonal elements of D (returned in workspace) and",
     "apply or reverse permutation done in TRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF."],
     "E"=>
      ["[out]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         E stores the supdiagonal/subdiagonal of the symmetric 1-by-1",
       "         or 2-by-2 block diagonal matrix D in LDLT."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slartgs"=>
  {"summary"=>
    ["SLARTGS generates a plane rotation designed to introduce a bulge in",
     "Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD",
     "problem. X and Y are the top-row entries, and SIGMA is the shift.",
     "The computed CS and SN define a plane rotation satisfying",
     "   [  CS  SN  ]  .  [ X^2 - SIGMA ]  =  [ R ],",
     "   [ -SN  CS  ]     [    X * Y    ]     [ 0 ]",
     "with R nonnegative.  If X^2 - SIGMA and X * Y are 0, then the",
     "rotation is by PI/2."],
   "param"=>
    {"X"=>
      ["[in]",
       "         X is REAL",
       "         The (1,1) entry of an upper bidiagonal matrix."],
     "Y"=>
      ["[in]",
       "         Y is REAL",
       "         The (1,2) entry of an upper bidiagonal matrix."],
     "SIGMA"=>["[in]", "         SIGMA is REAL", "         The shift."],
     "CS"=>
      ["[out]", "         CS is REAL", "         The cosine of the rotation."],
     "SN"=>
      ["[out]", "         SN is REAL", "         The sine of the rotation."]}},
 "dlaqsb"=>
  {"summary"=>
    ["DLAQSB equilibrates a symmetric band matrix A using the scaling",
     "factors in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**T*U or A = L*L**T of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is DOUBLE PRECISION",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "strttp"=>
  {"summary"=>
    ["STRTTP copies a triangular matrix A from full format (TR) to standard",
     "packed format (TP)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular.",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices AP and A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         On exit, the triangular matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AP"=>
      ["[out]",
       "         AP is REAL array, dimension (N*(N+1)/2",
       "         On exit, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgetf2"=>
  {"summary"=>
    ["SGETF2 computes an LU factorization of a general m-by-n matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the right-looking Level 2 BLAS version of the algorithm."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the m by n matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, U(k,k) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "dgeev"=>
  {"summary"=>
    ["DGEEV computes for an N-by-N real nonsymmetric matrix A, the",
     "eigenvalues and, optionally, the left and/or right eigenvectors.",
     "The right eigenvector v(j) of A satisfies",
     "                 A * v(j) = lambda(j) * v(j)",
     "where lambda(j) is its eigenvalue.",
     "The left eigenvector u(j) of A satisfies",
     "              u(j)**H * A = lambda(j) * u(j)**H",
     "where u(j)**H denotes the conjugate-transpose of u(j).",
     "The computed eigenvectors are normalized to have Euclidean norm",
     "equal to 1 and largest component real."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N': left eigenvectors of A are not computed;",
       "         = 'V': left eigenvectors of A are computed."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N': right eigenvectors of A are not computed;",
       "         = 'V': right eigenvectors of A are computed."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "WR"=>["[out]", "         WR is DOUBLE PRECISION array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is DOUBLE PRECISION array, dimension (N)",
       "         WR and WI contain the real and imaginary parts,",
       "         respectively, of the computed eigenvalues.  Complex",
       "         conjugate pairs of eigenvalues appear consecutively",
       "         with the eigenvalue having the positive imaginary part",
       "         first."],
     "VL"=>
      ["[out]",
       "         VL is DOUBLE PRECISION array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order",
       "         as their eigenvalues.",
       "         If JOBVL = 'N', VL is not referenced.",
       "         If the j-th eigenvalue is real, then u(j) = VL(:,j),",
       "         the j-th column of VL.",
       "         If the j-th and (j+1)-st eigenvalues form a complex",
       "         conjugate pair, then u(j) = VL(:,j) + i*VL(:,j+1) and",
       "         u(j+1) = VL(:,j) - i*VL(:,j+1)."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1; if",
       "         JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is DOUBLE PRECISION array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order",
       "         as their eigenvalues.",
       "         If JOBVR = 'N', VR is not referenced.",
       "         If the j-th eigenvalue is real, then v(j) = VR(:,j),",
       "         the j-th column of VR.",
       "         If the j-th and (j+1)-st eigenvalues form a complex",
       "         conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and",
       "         v(j+1) = VR(:,j) - i*VR(:,j+1)."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1; if",
       "         JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,3*N), and",
       "         if JOBVL = 'V' or JOBVR = 'V', LWORK >= 4*N.  For good",
       "         performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the QR algorithm failed to compute all the",
       "               eigenvalues, and no eigenvectors have been computed;",
       "               elements i+1:N of WR and WI contain eigenvalues which",
       "               have converged."]}},
 "slauum"=>
  {"summary"=>
    ["SLAUUM computes the product U * U**T or L**T * L, where the triangular",
     "factor U or L is stored in the upper or lower triangular part of",
     "the array A.",
     "If UPLO = 'U' or 'u' then the upper triangle of the result is stored,",
     "overwriting the factor U in A.",
     "If UPLO = 'L' or 'l' then the lower triangle of the result is stored,",
     "overwriting the factor L in A.",
     "This is the blocked form of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the triangular factor stored in the array A",
       "         is upper or lower triangular:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the triangular factor U or L.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L.",
       "         On exit, if UPLO = 'U', the upper triangle of A is",
       "         overwritten with the upper triangle of the product U * U**T;",
       "         if UPLO = 'L', the lower triangle of A is overwritten with",
       "         the lower triangle of the product L**T * L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "clanhp"=>
  {"summary"=>
    ["CLANHP  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex hermitian matrix A,  supplied in packed form.",
     "   CLANHP = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANHP as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         hermitian matrix A is supplied.",
       "         = 'U':  Upper triangular part of A is supplied",
       "         = 'L':  Lower triangular part of A is supplied"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANHP is",
       "         set to zero."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the hermitian matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         Note that the  imaginary parts of the diagonal elements need",
       "         not be set and are assumed to be zero."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "zsysv_rook"=>
  {"summary"=>
    ["ZSYSV_ROOK computes the solution to a complex system of linear",
     "equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "ZSYTRF_ROOK is called to compute the factorization of a complex",
     "symmetric matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal",
     "pivoting method.",
     "The factored form of A is then used to solve the system",
     "of equations A * X = B by calling ZSYTRS_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**T or A = L*D*L**T as computed by",
       "         ZSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D,",
       "         as determined by ZSYTRF_ROOK.",
       "         If UPLO = 'U':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k-1 and -IPIV(k-1) were inerchaged,",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k+1 and -IPIV(k+1) were inerchaged,",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         ZSYTRF_ROOK.",
       "         TRS will be done with Level 2 BLAS",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "zsytf2_rk"=>
  {"summary"=>
    ["ZSYTF2_RK computes the factorization of a complex symmetric matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "dlangt"=>
  {"summary"=>
    ["DLANGT  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "real tridiagonal matrix A.",
     "   DLANGT = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANGT as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, DLANGT is",
       "         set to zero."],
     "DL"=>
      ["[in]",
       "         DL is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) sub-diagonal elements of A."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of A."],
     "DU"=>
      ["[in]",
       "         DU is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) super-diagonal elements of A."]}},
 "dsbgv"=>
  {"summary"=>
    ["DSBGV computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite banded eigenproblem, of",
     "the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric",
     "and banded, and B is also positive definite."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is DOUBLE PRECISION array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(kb+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**T*S, as returned by DPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i). The eigenvectors are",
       "         normalized so that Z**T*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= N."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is:",
       "            <= N:  the algorithm failed to converge:",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then DPBSTF",
       "                   returned INFO = i: B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "slaed8"=>
  {"summary"=>
    ["SLAED8 merges the two sets of eigenvalues together into a single",
     "sorted set.  Then it tries to deflate the size of the problem.",
     "There are two ways in which deflation can occur:  when two or more",
     "eigenvalues are close together or if there is a tiny element in the",
     "Z vector.  For each such occurrence the order of the related secular",
     "equation problem is reduced by one."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "         = 0:  Compute eigenvalues only.",
       "         = 1:  Compute eigenvectors of original dense symmetric matrix",
       "               also.  On entry, Q contains the orthogonal matrix used",
       "               to reduce the original matrix to tridiagonal form."],
     "K"=>
      ["[out]",
       "         K is INTEGER",
       "        The number of non-deflated eigenvalues, and the order of the",
       "        related secular equation."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the orthogonal matrix used to reduce",
       "        the full matrix to tridiagonal form.  QSIZ >= N if ICOMPQ = 1."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry, the eigenvalues of the two submatrices to be",
       "        combined.  On exit, the trailing (N-K) updated eigenvalues",
       "        (those which were deflated) sorted into increasing order."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "        If ICOMPQ = 0, Q is not referenced.  Otherwise,",
       "        on entry, Q contains the eigenvectors of the partially solved",
       "        system which has been previously updated in matrix",
       "        multiplies with other partially solved eigensystems.",
       "        On exit, Q contains the trailing (N-K) updated eigenvectors",
       "        (those which were deflated) in its last N-K columns."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "INDXQ"=>
      ["[in]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        The permutation which separately sorts the two sub-problems",
       "        in D into ascending order.  Note that elements in the second",
       "        half of this permutation must first have CUTPNT added to",
       "        their values in order to be accurate."],
     "RHO"=>
      ["[in,out]",
       "         RHO is REAL",
       "        On entry, the off-diagonal element associated with the rank-1",
       "        cut which originally split the two submatrices which are now",
       "        being recombined.",
       "        On exit, RHO has been modified to the value required by",
       "        SLAED3."],
     "CUTPNT"=>
      ["[in]",
       "         CUTPNT is INTEGER",
       "        The location of the last eigenvalue in the leading",
       "        sub-matrix.  min(1,N) <= CUTPNT <= N."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension (N)",
       "        On entry, Z contains the updating vector (the last row of",
       "        the first sub-eigenvector matrix and the first row of the",
       "        second sub-eigenvector matrix).",
       "        On exit, the contents of Z are destroyed by the updating",
       "        process."],
     "DLAMDA"=>
      ["[out]",
       "         DLAMDA is REAL array, dimension (N)",
       "        A copy of the first K eigenvalues which will be used by",
       "        SLAED3 to form the secular equation."],
     "Q2"=>
      ["[out]",
       "         Q2 is REAL array, dimension (LDQ2,N)",
       "        If ICOMPQ = 0, Q2 is not referenced.  Otherwise,",
       "        a copy of the first K eigenvectors which will be used by",
       "        SLAED7 in a matrix multiply (SGEMM) to update the new",
       "        eigenvectors."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "        The leading dimension of the array Q2.  LDQ2 >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "        The first k values of the final deflation-altered z-vector and",
       "        will be passed to SLAED3."],
     "PERM"=>
      ["[out]",
       "         PERM is INTEGER array, dimension (N)",
       "        The permutations (from deflation and sorting) to be applied",
       "        to each eigenblock."],
     "GIVPTR"=>
      ["[out]",
       "         GIVPTR is INTEGER",
       "        The number of Givens rotations which took place in this",
       "        subproblem."],
     "GIVCOL"=>
      ["[out]",
       "         GIVCOL is INTEGER array, dimension (2, N)",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation."],
     "GIVNUM"=>
      ["[out]",
       "         GIVNUM is REAL array, dimension (2, N)",
       "        Each number indicates the S value to be used in the",
       "        corresponding Givens rotation."],
     "INDXP"=>
      ["[out]",
       "         INDXP is INTEGER array, dimension (N)",
       "        The permutation used to place deflated values of D at the end",
       "        of the array.  INDXP(1:K) points to the nondeflated D-values",
       "        and INDXP(K+1:N) points to the deflated eigenvalues."],
     "INDX"=>
      ["[out]",
       "         INDX is INTEGER array, dimension (N)",
       "        The permutation used to sort the contents of D into ascending",
       "        order."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zla_syrcond_x"=>
  {"summary"=>
    ["   ZLA_SYRCOND_X Computes the infinity norm condition number of",
     "   op(A) * diag(X) where X is a COMPLEX*16 vector."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by ZSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by ZSYTRF."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension (N)",
       "    The vector X in the formula op(A) * diag(X)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX*16 array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is DOUBLE PRECISION array, dimension (N).",
       "    Workspace."]}},
 "zla_syrfsx_extended"=>
  {"summary"=>
    ["ZLA_SYRFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by ZSYRFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by ZSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by ZSYTRF."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension",
       "                   (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by ZSYTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by ZLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is DOUBLE PRECISION array, dimension (N)",
       "    Workspace."],
     "DY"=>
      ["[in]",
       "         DY is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is DOUBLE PRECISION",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is DOUBLE PRECISION",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to ZLA_HERFSX_EXTENDED had an illegal",
       "            value"]}},
 "ssygst"=>
  {"summary"=>
    ["SSYGST reduces a real symmetric-definite generalized eigenproblem",
     "to standard form.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L.",
     "B must have been previously factorized as U**T*U or L*L**T by SPOTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T);",
       "         = 2 or 3: compute U*A*U**T or L**T*A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored and B is factored as",
       "                 U**T*U;",
       "         = 'L':  Lower triangle of A is stored and B is factored as",
       "                 L*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,N)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         as returned by SPOTRF."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgebd2"=>
  {"summary"=>
    ["ZGEBD2 reduces a complex general m by n matrix A to upper or lower",
     "real bidiagonal form B by a unitary transformation: Q**H * A * P = B.",
     "If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the m by n general matrix to be reduced.",
       "         On exit,",
       "         if m >= n, the diagonal and the first superdiagonal are",
       "           overwritten with the upper bidiagonal matrix B; the",
       "           elements below the diagonal, with the array TAUQ, represent",
       "           the unitary matrix Q as a product of elementary",
       "           reflectors, and the elements above the first superdiagonal,",
       "           with the array TAUP, represent the unitary matrix P as",
       "           a product of elementary reflectors;",
       "         if m < n, the diagonal and the first subdiagonal are",
       "           overwritten with the lower bidiagonal matrix B; the",
       "           elements below the first subdiagonal, with the array TAUQ,",
       "           represent the unitary matrix Q as a product of",
       "           elementary reflectors, and the elements above the diagonal,",
       "           with the array TAUP, represent the unitary matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (min(M,N)-1)",
       "         The off-diagonal elements of the bidiagonal matrix B:",
       "         if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;",
       "         if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is COMPLEX*16 array dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix P. See Further Details."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX*16 array, dimension (max(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value."]}},
 "zpftri"=>
  {"summary"=>
    ["ZPFTRI computes the inverse of a complex Hermitian positive definite",
     "matrix A using the Cholesky factorization A = U**H*U or A = L*L**H",
     "computed by ZPFTRF."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension ( N*(N+1)/2 );",
       "         On entry, the Hermitian matrix A in RFP format. RFP format is",
       "         described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'",
       "         then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'C' then RFP is",
       "         the Conjugate-transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the nt elements of",
       "         upper packed A. If UPLO = 'L' the RFP A contains the elements",
       "         of lower packed A. The LDA of RFP A is (N+1)/2 when TRANSR =",
       "         'C'. When TRANSR is 'N' the LDA is N+1 when N is even and N",
       "         is odd. See the Note below for more details.",
       "         On exit, the Hermitian inverse of the original matrix, in the",
       "         same storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "zsytrf_rook"=>
  {"summary"=>
    ["ZSYTRF_ROOK computes the factorization of a complex symmetric matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method.",
     "The form of the factorization is",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k-1 and -IPIV(k-1) were inerchaged,",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k+1 and -IPIV(k+1) were inerchaged,",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "dgetf2"=>
  {"summary"=>
    ["DGETF2 computes an LU factorization of a general m-by-n matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the right-looking Level 2 BLAS version of the algorithm."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the m by n matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, U(k,k) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "sgerfs"=>
  {"summary"=>
    ["SGERFS improves the computed solution to a system of linear",
     "equations and provides error bounds and backward error estimates for",
     "the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The original N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by SGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from SGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by SGETRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clange"=>
  {"summary"=>
    ["CLANGE  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex matrix A.",
     "   CLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANGE as described",
       "         above."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0.  When M = 0,",
       "         CLANGE is set to zero."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0.  When N = 0,",
       "         CLANGE is set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= M when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "ddisna"=>
  {"summary"=>
    ["DDISNA 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 m-by-n matrix. The reciprocal",
     "condition number is the 'gap' between the corresponding eigenvalue or",
     "singular value and the nearest other one.",
     "The bound on the error, measured by angle in radians, in the I-th",
     "computed vector is given by",
     "       DLAMCH( 'E' ) * ( ANORM / SEP( I ) )",
     "where ANORM = 2-norm(A) = max( abs( D(j) ) ).  SEP(I) is not allowed",
     "to be smaller than DLAMCH( 'E' )*ANORM in order to limit the size of",
     "the error bound.",
     "DDISNA may also be used to compute error bounds for eigenvectors of",
     "the generalized symmetric definite eigenproblem."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies for which problem the reciprocal condition numbers",
       "         should be computed:",
       "         = 'E':  the eigenvectors of a symmetric/Hermitian matrix;",
       "         = 'L':  the left singular vectors of a general matrix;",
       "         = 'R':  the right singular vectors of a general matrix."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         If JOB = 'L' or 'R', the number of columns of the matrix,",
       "         in which case N >= 0. Ignored if JOB = 'E'."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (M) if JOB = 'E'",
       "                             dimension (min(M,N)) if JOB = 'L' or 'R'",
       "         The eigenvalues (if JOB = 'E') or singular values (if JOB =",
       "         'L' or 'R') of the matrix, in either increasing or decreasing",
       "         order. If singular values, they must be non-negative."],
     "SEP"=>
      ["[out]",
       "         SEP is DOUBLE PRECISION array, dimension (M) if JOB = 'E'",
       "                              dimension (min(M,N)) if JOB = 'L' or 'R'",
       "         The reciprocal condition numbers of the vectors."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ztrttf"=>
  {"summary"=>
    ["ZTRTTF copies a triangular matrix A from standard full format (TR)",
     "to rectangular full packed format (TF) ."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF in Normal mode is wanted;",
       "         = 'C':  ARF in Conjugate Transpose mode is wanted;"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension ( LDA, N )",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the matrix A.  LDA >= max(1,N)."],
     "ARF"=>
      ["[out]",
       "         ARF is COMPLEX*16 array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgeqrt"=>
  {"summary"=>
    ["CGEQRT computes a blocked QR factorization of a complex M-by-N matrix A",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.  MIN(M,N) >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if M >= N); the elements below the diagonal",
       "         are the columns of V."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,MIN(M,N))",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (NB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zsprfs"=>
  {"summary"=>
    ["ZSPRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric indefinite",
     "and packed, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n."],
     "AFP"=>
      ["[in]",
       "         AFP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The factored form of the matrix A.  AFP contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**T or",
       "         A = L*D*L**T as computed by ZSPTRF, stored as a packed",
       "         triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSPTRF."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by ZSPTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ztgsja"=>
  {"summary"=>
    ["ZTGSJA computes the generalized singular value decomposition (GSVD)",
     "of two complex upper triangular (or trapezoidal) matrices A and B.",
     "On entry, it is assumed that matrices A and B have the following",
     "forms, which may be obtained by the preprocessing subroutine ZGGSVP",
     "from a general M-by-N matrix A and P-by-N matrix B:",
     "             N-K-L  K    L",
     "   A =    K ( 0    A12  A13 ) if M-K-L >= 0;",
     "          L ( 0     0   A23 )",
     "      M-K-L ( 0     0    0  )",
     "           N-K-L  K    L",
     "   A =  K ( 0    A12  A13 ) if M-K-L < 0;",
     "      M-K ( 0     0   A23 )",
     "           N-K-L  K    L",
     "   B =  L ( 0     0   B13 )",
     "      P-L ( 0     0    0  )",
     "where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular",
     "upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,",
     "otherwise A23 is (M-K)-by-L upper trapezoidal.",
     "On exit,",
     "       U**H *A*Q = D1*( 0 R ),    V**H *B*Q = D2*( 0 R ),",
     "where U, V and Q are unitary matrices.",
     "R is a nonsingular upper triangular matrix, and D1",
     "and D2 are ``diagonal'' matrices, which are of the following",
     "structures:",
     "If M-K-L >= 0,",
     "                    K  L",
     "       D1 =     K ( I  0 )",
     "                L ( 0  C )",
     "            M-K-L ( 0  0 )",
     "                   K  L",
     "       D2 = L   ( 0  S )",
     "            P-L ( 0  0 )",
     "               N-K-L  K    L",
     "  ( 0 R ) = K (  0   R11  R12 ) K",
     "            L (  0    0   R22 ) L",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(K+L) ),",
     "  S = diag( BETA(K+1),  ... , BETA(K+L) ),",
     "  C**2 + S**2 = I.",
     "  R is stored in A(1:K+L,N-K-L+1:N) on exit.",
     "If M-K-L < 0,",
     "               K M-K K+L-M",
     "    D1 =   K ( I  0    0   )",
     "         M-K ( 0  C    0   )",
     "                 K M-K K+L-M",
     "    D2 =   M-K ( 0  S    0   )",
     "         K+L-M ( 0  0    I   )",
     "           P-L ( 0  0    0   )",
     "               N-K-L  K   M-K  K+L-M",
     "( 0 R ) =    K ( 0    R11  R12  R13  )",
     "          M-K ( 0     0   R22  R23  )",
     "        K+L-M ( 0     0    0   R33  )",
     "where",
     "C = diag( ALPHA(K+1), ... , ALPHA(M) ),",
     "S = diag( BETA(K+1),  ... , BETA(M) ),",
     "C**2 + S**2 = I.",
     "R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored",
     "    (  0  R22 R23 )",
     "in B(M-K+1:L,N+M-K-L+1:N) on exit.",
     "The computation of the unitary transformation matrices U, V or Q",
     "is optional.  These matrices may either be formed explicitly, or they",
     "may be postmultiplied into input matrices U1, V1, or Q1."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  U must contain a unitary matrix U1 on entry, and",
       "                 the product U1*U is returned;",
       "         = 'I':  U is initialized to the unit matrix, and the",
       "                 unitary matrix U is returned;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  V must contain a unitary matrix V1 on entry, and",
       "                 the product V1*V is returned;",
       "         = 'I':  V is initialized to the unit matrix, and the",
       "                 unitary matrix V is returned;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Q must contain a unitary matrix Q1 on entry, and",
       "                 the product Q1*Q is returned;",
       "         = 'I':  Q is initialized to the unit matrix, and the",
       "                 unitary matrix Q is returned;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "K"=>["[in]", "         K is INTEGER"],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         K and L specify the subblocks in the input matrices A and B:",
       "         A23 = A(K+1:MIN(K+L,M),N-L+1:N) and B13 = B(1:L,,N-L+1:N)",
       "         of A and B, whose GSVD is going to be computed by ZTGSJA.",
       "         See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A(N-K+1:N,1:MIN(K+L,M) ) contains the triangular",
       "         matrix R or part of R.  See Purpose for details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, if necessary, B(M-K+1:L,N+M-K-L+1:N) contains",
       "         a part of R.  See Purpose for details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TOLA"=>["[in]", "         TOLA is DOUBLE PRECISION"],
     "TOLB"=>
      ["[in]",
       "         TOLB is DOUBLE PRECISION",
       "         TOLA and TOLB are the convergence criteria for the Jacobi-",
       "         Kogbetliantz iteration procedure. Generally, they are the",
       "         same as used in the preprocessing step, say",
       "             TOLA = MAX(M,N)*norm(A)*MAZHEPS,",
       "             TOLB = MAX(P,N)*norm(B)*MAZHEPS."],
     "ALPHA"=>
      ["[out]", "         ALPHA is DOUBLE PRECISION array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         On exit, ALPHA and BETA contain the generalized singular",
       "         value pairs of A and B;",
       "           ALPHA(1:K) = 1,",
       "           BETA(1:K)  = 0,",
       "         and if M-K-L >= 0,",
       "           ALPHA(K+1:K+L) = diag(C),",
       "           BETA(K+1:K+L)  = diag(S),",
       "         or if M-K-L < 0,",
       "           ALPHA(K+1:M)= C, ALPHA(M+1:K+L)= 0",
       "           BETA(K+1:M) = S, BETA(M+1:K+L) = 1.",
       "         Furthermore, if K+L < N,",
       "           ALPHA(K+L+1:N) = 0 and",
       "           BETA(K+L+1:N)  = 0."],
     "U"=>
      ["[in,out]",
       "         U is COMPLEX*16 array, dimension (LDU,M)",
       "         On entry, if JOBU = 'U', U must contain a matrix U1 (usually",
       "         the unitary matrix returned by ZGGSVP).",
       "         On exit,",
       "         if JOBU = 'I', U contains the unitary matrix U;",
       "         if JOBU = 'U', U contains the product U1*U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX*16 array, dimension (LDV,P)",
       "         On entry, if JOBV = 'V', V must contain a matrix V1 (usually",
       "         the unitary matrix returned by ZGGSVP).",
       "         On exit,",
       "         if JOBV = 'I', V contains the unitary matrix V;",
       "         if JOBV = 'V', V contains the product V1*V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,N)",
       "         On entry, if JOBQ = 'Q', Q must contain a matrix Q1 (usually",
       "         the unitary matrix returned by ZGGSVP).",
       "         On exit,",
       "         if JOBQ = 'I', Q contains the unitary matrix Q;",
       "         if JOBQ = 'Q', Q contains the product Q1*Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "NCYCLE"=>
      ["[out]",
       "         NCYCLE is INTEGER",
       "         The number of cycles required for convergence."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the procedure does not converge after MAXIT cycles."]}},
 "sgetsls"=>
  {"summary"=>
    ["SGETSLS solves overdetermined or underdetermined real linear systems",
     "involving an M-by-N matrix A, using a tall skinny QR or short wide LQ",
     "factorization of A.  It is assumed that A has full rank.",
     "The following options are provided:",
     "1. If TRANS = 'N' and m >= n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A*X ||.",
     "2. If TRANS = 'N' and m < n:  find the minimum norm solution of",
     "   an underdetermined system A * X = B.",
     "3. If TRANS = 'T' and m >= n:  find the minimum norm solution of",
     "   an undetermined system A**T * X = B.",
     "4. If TRANS = 'T' and m < n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A**T * X ||.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': the linear system involves A;",
       "         = 'T': the linear system involves A**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of the matrices B and X. NRHS >=0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         A is overwritten by details of its QR or LQ",
       "         factorization as returned by SGEQR or SGELQ."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the matrix B of right hand side vectors, stored",
       "         columnwise; B is M-by-NRHS if TRANS = 'N', or N-by-NRHS",
       "         if TRANS = 'T'.",
       "         On exit, if INFO = 0, B is overwritten by the solution",
       "         vectors, stored columnwise:",
       "         if TRANS = 'N' and m >= n, rows 1 to n of B contain the least",
       "         squares solution vectors.",
       "         if TRANS = 'N' and m < n, rows 1 to N of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'T' and m >= n, rows 1 to M of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'T' and m < n, rows 1 to M of B contain the",
       "         least squares solution vectors."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= MAX(1,M,N)."],
     "WORK"=>
      ["[out]",
       "         (workspace) REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO =  i, the i-th diagonal element of the",
       "               triangular factor of A is zero, so that A does not have",
       "               full rank; the least squares solution could not be",
       "               computed."]}},
 "zhetrf_aa"=>
  {"summary"=>
    ["ZHETRF_AA computes the factorization of a complex hermitian matrix A",
     "using the Aasen's algorithm.  The form of the factorization is",
     "   A = U*T*U**H  or  A = L*T*L**H",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is a hermitian tridiagonal matrix.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the tridiagonal matrix is stored in the diagonals",
       "         and the subdiagonals of A just below (or above) the diagonals,",
       "         and L is stored below (or above) the subdiaonals, when UPLO",
       "         is 'L' (or 'U')."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK. LWORK >= MAX(1,2*N). For optimum performance",
       "         LWORK >= N*(1+NB), where NB is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "ctgsja"=>
  {"summary"=>
    ["CTGSJA computes the generalized singular value decomposition (GSVD)",
     "of two complex upper triangular (or trapezoidal) matrices A and B.",
     "On entry, it is assumed that matrices A and B have the following",
     "forms, which may be obtained by the preprocessing subroutine CGGSVP",
     "from a general M-by-N matrix A and P-by-N matrix B:",
     "             N-K-L  K    L",
     "   A =    K ( 0    A12  A13 ) if M-K-L >= 0;",
     "          L ( 0     0   A23 )",
     "      M-K-L ( 0     0    0  )",
     "           N-K-L  K    L",
     "   A =  K ( 0    A12  A13 ) if M-K-L < 0;",
     "      M-K ( 0     0   A23 )",
     "           N-K-L  K    L",
     "   B =  L ( 0     0   B13 )",
     "      P-L ( 0     0    0  )",
     "where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular",
     "upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,",
     "otherwise A23 is (M-K)-by-L upper trapezoidal.",
     "On exit,",
     "       U**H *A*Q = D1*( 0 R ),    V**H *B*Q = D2*( 0 R ),",
     "where U, V and Q are unitary matrices.",
     "R is a nonsingular upper triangular matrix, and D1",
     "and D2 are ``diagonal'' matrices, which are of the following",
     "structures:",
     "If M-K-L >= 0,",
     "                    K  L",
     "       D1 =     K ( I  0 )",
     "                L ( 0  C )",
     "            M-K-L ( 0  0 )",
     "                   K  L",
     "       D2 = L   ( 0  S )",
     "            P-L ( 0  0 )",
     "               N-K-L  K    L",
     "  ( 0 R ) = K (  0   R11  R12 ) K",
     "            L (  0    0   R22 ) L",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(K+L) ),",
     "  S = diag( BETA(K+1),  ... , BETA(K+L) ),",
     "  C**2 + S**2 = I.",
     "  R is stored in A(1:K+L,N-K-L+1:N) on exit.",
     "If M-K-L < 0,",
     "               K M-K K+L-M",
     "    D1 =   K ( I  0    0   )",
     "         M-K ( 0  C    0   )",
     "                 K M-K K+L-M",
     "    D2 =   M-K ( 0  S    0   )",
     "         K+L-M ( 0  0    I   )",
     "           P-L ( 0  0    0   )",
     "               N-K-L  K   M-K  K+L-M",
     "( 0 R ) =    K ( 0    R11  R12  R13  )",
     "          M-K ( 0     0   R22  R23  )",
     "        K+L-M ( 0     0    0   R33  )",
     "where",
     "C = diag( ALPHA(K+1), ... , ALPHA(M) ),",
     "S = diag( BETA(K+1),  ... , BETA(M) ),",
     "C**2 + S**2 = I.",
     "R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored",
     "    (  0  R22 R23 )",
     "in B(M-K+1:L,N+M-K-L+1:N) on exit.",
     "The computation of the unitary transformation matrices U, V or Q",
     "is optional.  These matrices may either be formed explicitly, or they",
     "may be postmultiplied into input matrices U1, V1, or Q1."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  U must contain a unitary matrix U1 on entry, and",
       "                 the product U1*U is returned;",
       "         = 'I':  U is initialized to the unit matrix, and the",
       "                 unitary matrix U is returned;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  V must contain a unitary matrix V1 on entry, and",
       "                 the product V1*V is returned;",
       "         = 'I':  V is initialized to the unit matrix, and the",
       "                 unitary matrix V is returned;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Q must contain a unitary matrix Q1 on entry, and",
       "                 the product Q1*Q is returned;",
       "         = 'I':  Q is initialized to the unit matrix, and the",
       "                 unitary matrix Q is returned;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "K"=>["[in]", "         K is INTEGER"],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         K and L specify the subblocks in the input matrices A and B:",
       "         A23 = A(K+1:MIN(K+L,M),N-L+1:N) and B13 = B(1:L,,N-L+1:N)",
       "         of A and B, whose GSVD is going to be computed by CTGSJA.",
       "         See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A(N-K+1:N,1:MIN(K+L,M) ) contains the triangular",
       "         matrix R or part of R.  See Purpose for details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, if necessary, B(M-K+1:L,N+M-K-L+1:N) contains",
       "         a part of R.  See Purpose for details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TOLA"=>["[in]", "         TOLA is REAL"],
     "TOLB"=>
      ["[in]",
       "         TOLB is REAL",
       "         TOLA and TOLB are the convergence criteria for the Jacobi-",
       "         Kogbetliantz iteration procedure. Generally, they are the",
       "         same as used in the preprocessing step, say",
       "             TOLA = MAX(M,N)*norm(A)*MACHEPS,",
       "             TOLB = MAX(P,N)*norm(B)*MACHEPS."],
     "ALPHA"=>["[out]", "         ALPHA is REAL array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         On exit, ALPHA and BETA contain the generalized singular",
       "         value pairs of A and B;",
       "           ALPHA(1:K) = 1,",
       "           BETA(1:K)  = 0,",
       "         and if M-K-L >= 0,",
       "           ALPHA(K+1:K+L) = diag(C),",
       "           BETA(K+1:K+L)  = diag(S),",
       "         or if M-K-L < 0,",
       "           ALPHA(K+1:M)= C, ALPHA(M+1:K+L)= 0",
       "           BETA(K+1:M) = S, BETA(M+1:K+L) = 1.",
       "         Furthermore, if K+L < N,",
       "           ALPHA(K+L+1:N) = 0",
       "           BETA(K+L+1:N)  = 0."],
     "U"=>
      ["[in,out]",
       "         U is COMPLEX array, dimension (LDU,M)",
       "         On entry, if JOBU = 'U', U must contain a matrix U1 (usually",
       "         the unitary matrix returned by CGGSVP).",
       "         On exit,",
       "         if JOBU = 'I', U contains the unitary matrix U;",
       "         if JOBU = 'U', U contains the product U1*U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX array, dimension (LDV,P)",
       "         On entry, if JOBV = 'V', V must contain a matrix V1 (usually",
       "         the unitary matrix returned by CGGSVP).",
       "         On exit,",
       "         if JOBV = 'I', V contains the unitary matrix V;",
       "         if JOBV = 'V', V contains the product V1*V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDQ,N)",
       "         On entry, if JOBQ = 'Q', Q must contain a matrix Q1 (usually",
       "         the unitary matrix returned by CGGSVP).",
       "         On exit,",
       "         if JOBQ = 'I', Q contains the unitary matrix Q;",
       "         if JOBQ = 'Q', Q contains the product Q1*Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "NCYCLE"=>
      ["[out]",
       "         NCYCLE is INTEGER",
       "         The number of cycles required for convergence."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the procedure does not converge after MAXIT cycles."]}},
 "ssytf2_rook"=>
  {"summary"=>
    ["SSYTF2_ROOK computes the factorization of a real symmetric matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**T is the transpose of U, and D is symmetric and",
     "block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "slangt"=>
  {"summary"=>
    ["SLANGT  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "real tridiagonal matrix A.",
     "   SLANGT = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANGT as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, SLANGT is",
       "         set to zero."],
     "DL"=>
      ["[in]",
       "         DL is REAL array, dimension (N-1)",
       "         The (n-1) sub-diagonal elements of A."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of A."],
     "DU"=>
      ["[in]",
       "         DU is REAL array, dimension (N-1)",
       "         The (n-1) super-diagonal elements of A."]}},
 "dlaed1"=>
  {"summary"=>
    ["DLAED1 computes the updated eigensystem of a diagonal",
     "matrix after modification by a rank-one symmetric matrix.  This",
     "routine is used only for the eigenproblem which requires all",
     "eigenvalues and eigenvectors of a tridiagonal matrix.  DLAED7 handles",
     "the case in which eigenvalues only or eigenvalues and eigenvectors",
     "of a full symmetric matrix (which was reduced to tridiagonal form)",
     "are desired.",
     "  T = Q(in) ( D(in) + RHO * Z*Z**T ) Q**T(in) = Q(out) * D(out) * Q**T(out)",
     "   where Z = Q**T*u, u is a vector of length N with ones in the",
     "   CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.",
     "   The eigenvectors of the original matrix are stored in Q, and the",
     "   eigenvalues are in D.  The algorithm consists of three stages:",
     "      The first stage consists of deflating the size of the problem",
     "      when there are multiple eigenvalues or if there is a zero in",
     "      the Z vector.  For each such occurrence the dimension of the",
     "      secular equation problem is reduced by one.  This stage is",
     "      performed by the routine DLAED2.",
     "      The second stage consists of calculating the updated",
     "      eigenvalues. This is done by finding the roots of the secular",
     "      equation via the routine DLAED4 (as called by DLAED3).",
     "      This routine also calculates the eigenvectors of the current",
     "      problem.",
     "      The final stage consists of computing the updated eigenvectors",
     "      directly using the updated eigenvalues.  The eigenvectors for",
     "      the current problem are multiplied with the eigenvectors from",
     "      the overall problem."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        On entry, the eigenvalues of the rank-1-perturbed matrix.",
       "        On exit, the eigenvalues of the repaired matrix."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "        On entry, the eigenvectors of the rank-1-perturbed matrix.",
       "        On exit, the eigenvectors of the repaired tridiagonal matrix."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "INDXQ"=>
      ["[in,out]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        On entry, the permutation which separately sorts the two",
       "        subproblems in D into ascending order.",
       "        On exit, the permutation which will reintegrate the",
       "        subproblems back into sorted order,",
       "        i.e. D( INDXQ( I = 1, N ) ) will be in ascending order."],
     "RHO"=>
      ["[in]",
       "         RHO is DOUBLE PRECISION",
       "        The subdiagonal entry used to create the rank-1 modification."],
     "CUTPNT"=>
      ["[in]",
       "         CUTPNT is INTEGER",
       "        The location of the last eigenvalue in the leading sub-matrix.",
       "        min(1,N) <= CUTPNT <= N/2."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (4*N + N**2)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, an eigenvalue did not converge"]}},
 "spoequ"=>
  {"summary"=>
    ["SPOEQU computes row and column scalings intended to equilibrate a",
     "symmetric positive definite matrix A and reduce its condition number",
     "(with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The N-by-N symmetric positive definite matrix whose scaling",
       "         factors are to be computed.  Only the diagonal elements of A",
       "         are referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is REAL",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "dstevd"=>
  {"summary"=>
    ["DSTEVD computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric tridiagonal matrix. If eigenvectors are desired, it",
     "uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A, stored in elements 1 to N-1 of E.",
       "         On exit, the contents of E are destroyed."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with D(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array,",
       "                                        dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If JOBZ  = 'N' or N <= 1 then LWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1 then LWORK must be at least",
       "                        ( 1 + 4*N + N**2 ).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1 then LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1 then LIWORK must be at least 3+5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of E did not converge to zero."]}},
 "zlascl"=>
  {"summary"=>
    ["ZLASCL multiplies the M by N complex matrix A by the real scalar",
     "CTO/CFROM.  This is done without over/underflow as long as the final",
     "result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that",
     "A may be full, upper triangular, lower triangular, upper Hessenberg,",
     "or banded."],
   "param"=>
    {"TYPE"=>
      ["[in]",
       "         TYPE is CHARACTER*1",
       "         TYPE indices the storage type of the input matrix.",
       "         = 'G':  A is a full matrix.",
       "         = 'L':  A is a lower triangular matrix.",
       "         = 'U':  A is an upper triangular matrix.",
       "         = 'H':  A is an upper Hessenberg matrix.",
       "         = 'B':  A is a symmetric band matrix with lower bandwidth KL",
       "                 and upper bandwidth KU and with the only the lower",
       "                 half stored.",
       "         = 'Q':  A is a symmetric band matrix with lower bandwidth KL",
       "                 and upper bandwidth KU and with the only the upper",
       "                 half stored.",
       "         = 'Z':  A is a band matrix with lower bandwidth KL and upper",
       "                 bandwidth KU. See ZGBTRF for storage details."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The lower bandwidth of A.  Referenced only if TYPE = 'B',",
       "         'Q' or 'Z'."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The upper bandwidth of A.  Referenced only if TYPE = 'B',",
       "         'Q' or 'Z'."],
     "CFROM"=>["[in]", "         CFROM is DOUBLE PRECISION"],
     "CTO"=>
      ["[in]",
       "         CTO is DOUBLE PRECISION",
       "         The matrix A is multiplied by CTO/CFROM. A(I,J) is computed",
       "         without over/underflow if the final result CTO*A(I,J)/CFROM",
       "         can be represented without over/underflow.  CFROM must be",
       "         nonzero."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The matrix to be multiplied by CTO/CFROM.  See TYPE for the",
       "         storage type."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If TYPE = 'G', 'L', 'U', 'H', LDA >= max(1,M);",
       "            TYPE = 'B', LDA >= KL+1;",
       "            TYPE = 'Q', LDA >= KU+1;",
       "            TYPE = 'Z', LDA >= 2*KL+KU+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         0  - successful exit",
       "         <0 - if INFO = -i, the i-th argument had an illegal value."]}},
 "dpotri"=>
  {"summary"=>
    ["DPOTRI computes the inverse of a real symmetric positive definite",
     "matrix A using the Cholesky factorization A = U**T*U or A = L*L**T",
     "computed by DPOTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T, as computed by",
       "         DPOTRF.",
       "         On exit, the upper or lower triangle of the (symmetric)",
       "         inverse of A, overwriting the input factor U or L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "cgeqp3"=>
  {"summary"=>
    ["CGEQP3 computes a QR factorization with column pivoting of a",
     "matrix A:  A*P = Q*R  using Level 3 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the upper triangle of the array contains the",
       "         min(M,N)-by-N upper trapezoidal matrix R; the elements below",
       "         the diagonal, together with the array TAU, represent the",
       "         unitary matrix Q as a product of min(M,N) elementary",
       "         reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(J).ne.0, the J-th column of A is permuted",
       "         to the front of A*P (a leading column); if JPVT(J)=0,",
       "         the J-th column of A is a free column.",
       "         On exit, if JPVT(J)=K, then the J-th column of A*P was the",
       "         the K-th column of A."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO=0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= N+1.",
       "         For optimal performance LWORK >= ( N+1 )*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit.",
       "         < 0: if INFO = -i, the i-th argument had an illegal value."]}},
 "dstevr"=>
  {"summary"=>
    ["DSTEVR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix T.  Eigenvalues and",
     "eigenvectors can be selected by specifying either a range of values",
     "or a range of indices for the desired eigenvalues.",
     "Whenever possible, DSTEVR calls DSTEMR to compute the",
     "eigenspectrum using Relatively Robust Representations.  DSTEMR",
     "computes eigenvalues by the dqds algorithm, while orthogonal",
     "eigenvectors are computed from various \"good\" L D L^T representations",
     "(also known as Relatively Robust Representations). Gram-Schmidt",
     "orthogonalization is avoided as far as possible. More specifically,",
     "the various steps of the algorithm are as follows. For the i-th",
     "unreduced block of T,",
     "   (a) Compute T - sigma_i = L_i D_i L_i^T, such that L_i D_i L_i^T",
     "        is a relatively robust representation,",
     "   (b) Compute the eigenvalues, lambda_j, of L_i D_i L_i^T to high",
     "       relative accuracy by the dqds algorithm,",
     "   (c) If there is a cluster of close eigenvalues, \"choose\" sigma_i",
     "       close to the cluster, and go to step (a),",
     "   (d) Given the approximate eigenvalue lambda_j of L_i D_i L_i^T,",
     "       compute the corresponding eigenvector by forming a",
     "       rank-revealing twisted factorization.",
     "The desired accuracy of the output can be specified by the input",
     "parameter ABSTOL.",
     "For more details, see \"A new O(n^2) algorithm for the symmetric",
     "tridiagonal eigenvalue/eigenvector problem\", by Inderjit Dhillon,",
     "Computer Science Division Technical Report No. UCB//CSD-97-971,",
     "UC Berkeley, May 1997.",
     "Note 1 : DSTEVR calls DSTEMR when the full spectrum is requested",
     "on machines which conform to the ieee-754 floating point standard.",
     "DSTEVR calls DSTEBZ and DSTEIN on non-ieee machines and",
     "when partial spectrum requests are made.",
     "Normal execution of DSTEMR may create NaNs and infinities and",
     "hence may abort due to a floating point exception in environments",
     "which do not handle NaNs and infinities in the ieee standard default",
     "manner."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found.",
       "         For RANGE = 'V' or 'I' and IU - IL < N - 1, DSTEBZ and",
       "         DSTEIN are called"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.",
       "         On exit, D may be multiplied by a constant factor chosen",
       "         to avoid over/underflow in computing the eigenvalues."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (max(1,N-1))",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A in elements 1 to N-1 of E.",
       "         On exit, E may be multiplied by a constant factor chosen",
       "         to avoid over/underflow in computing the eigenvalues."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3.",
       "         If high relative accuracy is important, set ABSTOL to",
       "         DLAMCH( 'Safe minimum' ).  Doing so will guarantee that",
       "         eigenvalues are computed to high relative accuracy when",
       "         possible in future releases.  The current code does not",
       "         make any guarantees about high relative accuracy, but",
       "         future releases will. See J. Barlow and J. Demmel,",
       "         \"Computing Accurate Eigensystems of Scaled Diagonally",
       "         Dominant Matrices\", LAPACK Working Note #7, for a discussion",
       "         of which matrices define their eigenvalues to high relative",
       "         accuracy."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ).",
       "         Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1"],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal (and",
       "         minimal) LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,20*N).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal (and",
       "         minimal) LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  Internal error"]}},
 "cupgtr"=>
  {"summary"=>
    ["CUPGTR generates a complex unitary matrix Q which is defined as the",
     "product of n-1 elementary reflectors H(i) of order n, as returned by",
     "CHPTRD using packed storage:",
     "if UPLO = 'U', Q = H(n-1) . . . H(2) H(1),",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(n-1)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangular packed storage used in previous",
       "                call to CHPTRD;",
       "         = 'L': Lower triangular packed storage used in previous",
       "                call to CHPTRD."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The vectors which define the elementary reflectors, as",
       "         returned by CHPTRD."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CHPTRD."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX array, dimension (LDQ,N)",
       "         The N-by-N unitary matrix Q."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N-1)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "spbrfs"=>
  {"summary"=>
    ["SPBRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric positive definite",
     "and banded, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The upper or lower triangle of the symmetric band matrix A,",
       "         stored in the first KD+1 rows of the array.  The j-th column",
       "         of A is stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "AFB"=>
      ["[in]",
       "         AFB is REAL array, dimension (LDAFB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T of the band matrix A as computed by",
       "         SPBTRF, in the same storage format as A (see AB)."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "         The leading dimension of the array AFB.  LDAFB >= KD+1."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by SPBTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaev2"=>
  {"summary"=>
    ["DLAEV2 computes the eigendecomposition of a 2-by-2 symmetric matrix",
     "   [  A   B  ]",
     "   [  B   C  ].",
     "On return, RT1 is the eigenvalue of larger absolute value, RT2 is the",
     "eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right",
     "eigenvector for RT1, giving the decomposition",
     "   [ CS1  SN1 ] [  A   B  ] [ CS1 -SN1 ]  =  [ RT1  0  ]",
     "   [-SN1  CS1 ] [  B   C  ] [ SN1  CS1 ]     [  0  RT2 ]."],
   "param"=>
    {"A"=>
      ["[in]",
       "         A is DOUBLE PRECISION",
       "         The (1,1) element of the 2-by-2 matrix."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION",
       "         The (1,2) element and the conjugate of the (2,1) element of",
       "         the 2-by-2 matrix."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION",
       "         The (2,2) element of the 2-by-2 matrix."],
     "RT1"=>
      ["[out]",
       "         RT1 is DOUBLE PRECISION",
       "         The eigenvalue of larger absolute value."],
     "RT2"=>
      ["[out]",
       "         RT2 is DOUBLE PRECISION",
       "         The eigenvalue of smaller absolute value."],
     "CS1"=>["[out]", "         CS1 is DOUBLE PRECISION"],
     "SN1"=>
      ["[out]",
       "         SN1 is DOUBLE PRECISION",
       "         The vector (CS1, SN1) is a unit right eigenvector for RT1."]}},
 "sgebak"=>
  {"summary"=>
    ["SGEBAK forms the right or left eigenvectors of a real general matrix",
     "by backward transformation on the computed eigenvectors of the",
     "balanced matrix output by SGEBAL."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the type of backward transformation required:",
       "         = 'N', do nothing, return immediately;",
       "         = 'P', do backward transformation for permutation only;",
       "         = 'S', do backward transformation for scaling only;",
       "         = 'B', do backward transformations for both permutation and",
       "                scaling.",
       "         JOB must be the same as the argument JOB supplied to SGEBAL."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  V contains right eigenvectors;",
       "         = 'L':  V contains left eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrix V.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         The integers ILO and IHI determined by SGEBAL.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "SCALE"=>
      ["[in]",
       "         SCALE is REAL array, dimension (N)",
       "         Details of the permutation and scaling factors, as returned",
       "         by SGEBAL."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix V.  M >= 0."],
     "V"=>
      ["[in,out]",
       "         V is REAL array, dimension (LDV,M)",
       "         On entry, the matrix of right or left eigenvectors to be",
       "         transformed, as returned by SHSEIN or STREVC.",
       "         On exit, V is overwritten by the transformed eigenvectors."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zlarscl2"=>
  {"summary"=>
    ["ZLARSCL2 performs a reciprocal diagonal scaling on an vector:",
     "  x <-- inv(D) * x",
     "where the DOUBLE PRECISION diagonal matrix D is stored as a vector.",
     "Eventually to be replaced by BLAS_zge_diag_scale in the new BLAS",
     "standard."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "    The number of rows of D and X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of columns of X. N >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, length M",
       "    Diagonal matrix D, stored as a vector of length M."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,N)",
       "    On entry, the vector X to be scaled by D.",
       "    On exit, the scaled vector."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the vector X. LDX >= M."]}},
 "zlantr"=>
  {"summary"=>
    ["ZLANTR  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "trapezoidal or triangular matrix A.",
     "   ZLANTR = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANTR as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower trapezoidal.",
       "         = 'U':  Upper trapezoidal",
       "         = 'L':  Lower trapezoidal",
       "         Note that A is triangular instead of trapezoidal if M = N."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A has unit diagonal.",
       "         = 'N':  Non-unit diagonal",
       "         = 'U':  Unit diagonal"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0, and if",
       "         UPLO = 'U', M <= N.  When M = 0, ZLANTR is set to zero."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0, and if",
       "         UPLO = 'L', N <= M.  When N = 0, ZLANTR is set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The trapezoidal matrix A (A is triangular if M = N).",
       "         If UPLO = 'U', the leading m by n upper trapezoidal part of",
       "         the array A contains the upper trapezoidal matrix, and the",
       "         strictly lower triangular part of A is not referenced.",
       "         If UPLO = 'L', the leading m by n lower trapezoidal part of",
       "         the array A contains the lower trapezoidal matrix, and the",
       "         strictly upper triangular part of A is not referenced.  Note",
       "         that when DIAG = 'U', the diagonal elements of A are not",
       "         referenced and are assumed to be one."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= M when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "slapmt"=>
  {"summary"=>
    ["SLAPMT rearranges the columns of the M by N matrix X as specified",
     "by the permutation K(1),K(2),...,K(N) of the integers 1,...,N.",
     "If FORWRD = .TRUE.,  forward permutation:",
     "     X(*,K(J)) is moved X(*,J) for J = 1,2,...,N.",
     "If FORWRD = .FALSE., backward permutation:",
     "     X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N."],
   "param"=>
    {"FORWRD"=>
      ["[in]",
       "         FORWRD is LOGICAL",
       "         = .TRUE., forward permutation",
       "         = .FALSE., backward permutation"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix X. N >= 0."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,N)",
       "         On entry, the M by N matrix X.",
       "         On exit, X contains the permuted matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X, LDX >= MAX(1,M)."],
     "K"=>
      ["[in,out]",
       "         K is INTEGER array, dimension (N)",
       "         On entry, K contains the permutation vector. K is used as",
       "         internal workspace, but reset to its original value on",
       "         output."]}},
 "dla_syrcond"=>
  {"summary"=>
    ["   DLA_SYRCOND estimates the Skeel condition number of  op(A) * op2(C)",
     "   where op2 is determined by CMODE as follows",
     "   CMODE =  1    op2(C) = C",
     "   CMODE =  0    op2(C) = I",
     "   CMODE = -1    op2(C) = inv(C)",
     "   The Skeel condition number cond(A) = norminf( |inv(A)||A| )",
     "   is computed by computing scaling factors R such that",
     "   diag(R)*A*op2(C) is row equilibrated and computing the standard",
     "   infinity-norm condition number."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by DSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by DSYTRF."],
     "CMODE"=>
      ["[in]",
       "         CMODE is INTEGER",
       "    Determines op2(C) in the formula op(A) * op2(C) as follows:",
       "    CMODE =  1    op2(C) = C",
       "    CMODE =  0    op2(C) = I",
       "    CMODE = -1    op2(C) = inv(C)"],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The vector C in the formula op(A) * op2(C)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is DOUBLE PRECISION array, dimension (3*N).",
       "    Workspace."],
     "IWORK"=>
      ["[in]",
       "         IWORK is INTEGER array, dimension (N).",
       "    Workspace."]}},
 "cggrqf"=>
  {"summary"=>
    ["CGGRQF computes a generalized RQ factorization of an M-by-N matrix A",
     "and a P-by-N matrix B:",
     "            A = R*Q,        B = Z*T*Q,",
     "where Q is an N-by-N unitary matrix, Z is a P-by-P unitary",
     "matrix, and R and T assume one of the forms:",
     "if M <= N,  R = ( 0  R12 ) M,   or if M > N,  R = ( R11 ) M-N,",
     "                 N-M  M                           ( R21 ) N",
     "                                                     N",
     "where R12 or R21 is upper triangular, and",
     "if P >= N,  T = ( T11 ) N  ,   or if P < N,  T = ( T11  T12 ) P,",
     "                (  0  ) P-N                         P   N-P",
     "                   N",
     "where T11 is upper triangular.",
     "In particular, if B is square and nonsingular, the GRQ factorization",
     "of A and B implicitly gives the RQ factorization of A*inv(B):",
     "             A*inv(B) = (R*inv(T))*Z**H",
     "where inv(B) denotes the inverse of the matrix B, and Z**H denotes the",
     "conjugate transpose of the matrix Z."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, if M <= N, the upper triangle of the subarray",
       "         A(1:M,N-M+1:N) contains the M-by-M upper triangular matrix R;",
       "         if M > N, the elements on and above the (M-N)-th subdiagonal",
       "         contain the M-by-N upper trapezoidal matrix R; the remaining",
       "         elements, with the array TAUA, represent the unitary",
       "         matrix Q as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "TAUA"=>
      ["[out]",
       "         TAUA is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Q (see Further Details)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(P,N)-by-N upper trapezoidal matrix T (T is",
       "         upper triangular if P >= N); the elements below the diagonal,",
       "         with the array TAUB, represent the unitary matrix Z as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TAUB"=>
      ["[out]",
       "         TAUB is COMPLEX array, dimension (min(P,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Z (see Further Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N,M,P).",
       "         For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),",
       "         where NB1 is the optimal blocksize for the RQ factorization",
       "         of an M-by-N matrix, NB2 is the optimal blocksize for the",
       "         QR factorization of a P-by-N matrix, and NB3 is the optimal",
       "         blocksize for a call of CUNMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO=-i, the i-th argument had an illegal value."]}},
 "sorcsd"=>
  {"summary"=>
    ["SORCSD computes the CS decomposition of an M-by-M partitioned",
     "orthogonal matrix X:",
     "                                [  I  0  0 |  0  0  0 ]",
     "                                [  0  C  0 |  0 -S  0 ]",
     "    [ X11 | X12 ]   [ U1 |    ] [  0  0  0 |  0  0 -I ] [ V1 |    ]**T",
     "X = [-----------] = [---------] [---------------------] [---------]   .",
     "    [ X21 | X22 ]   [    | U2 ] [  0  0  0 |  I  0  0 ] [    | V2 ]",
     "                                [  0  S  0 |  0  C  0 ]",
     "                                [  0  0  I |  0  0  0 ]",
     "X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P,",
     "(M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are",
     "R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in",
     "which R = MIN(P,M-P,Q,M-Q)."],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is computed;",
       "         otherwise:  U1 is not computed."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is computed;",
       "         otherwise:  U2 is not computed."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is computed;",
       "         otherwise:  V1T is not computed."],
     "JOBV2T"=>
      ["[in]",
       "         JOBV2T is CHARACTER",
       "         = 'Y':      V2T is computed;",
       "         otherwise:  V2T is not computed."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "SIGNS"=>
      ["[in]",
       "         SIGNS is CHARACTER",
       "         = 'O':      The lower-left block is made nonpositive (the",
       "                     \"other\" convention);",
       "         otherwise:  The upper-right block is made nonpositive (the",
       "                     \"default\" convention)."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11 and X12. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is REAL array, dimension (LDX11,Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. LDX11 >= MAX(1,P)."],
     "X12"=>
      ["[in,out]",
       "         X12 is REAL array, dimension (LDX12,M-Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX12"=>
      ["[in]",
       "         LDX12 is INTEGER",
       "         The leading dimension of X12. LDX12 >= MAX(1,P)."],
     "X21"=>
      ["[in,out]",
       "         X21 is REAL array, dimension (LDX21,Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "         The leading dimension of X11. LDX21 >= MAX(1,M-P)."],
     "X22"=>
      ["[in,out]",
       "         X22 is REAL array, dimension (LDX22,M-Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX22"=>
      ["[in]",
       "         LDX22 is INTEGER",
       "         The leading dimension of X11. LDX22 >= MAX(1,M-P)."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (R), in which R =",
       "         MIN(P,M-P,Q,M-Q).",
       "         C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and",
       "         S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) )."],
     "U1"=>
      ["[out]",
       "         U1 is REAL array, dimension (P)",
       "         If JOBU1 = 'Y', U1 contains the P-by-P orthogonal matrix U1."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of U1. If JOBU1 = 'Y', LDU1 >=",
       "         MAX(1,P)."],
     "U2"=>
      ["[out]",
       "         U2 is REAL array, dimension (M-P)",
       "         If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) orthogonal",
       "         matrix U2."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of U2. If JOBU2 = 'Y', LDU2 >=",
       "         MAX(1,M-P)."],
     "V1T"=>
      ["[out]",
       "         V1T is REAL array, dimension (Q)",
       "         If JOBV1T = 'Y', V1T contains the Q-by-Q matrix orthogonal",
       "         matrix V1**T."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >=",
       "         MAX(1,Q)."],
     "V2T"=>
      ["[out]",
       "         V2T is REAL array, dimension (M-Q)",
       "         If JOBV2T = 'Y', V2T contains the (M-Q)-by-(M-Q) orthogonal",
       "         matrix V2**T."],
     "LDV2T"=>
      ["[in]",
       "         LDV2T is INTEGER",
       "         The leading dimension of V2T. If JOBV2T = 'Y', LDV2T >=",
       "         MAX(1,M-Q)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK.",
       "         If INFO > 0 on exit, WORK(2:R) contains the values PHI(1),",
       "         ..., PHI(R-1) that, together with THETA(1), ..., THETA(R),",
       "         define the matrix in intermediate bidiagonal-block form",
       "         remaining after nonconvergence. INFO specifies the number",
       "         of nonzero PHI's."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (M-MIN(P, M-P, Q, M-Q))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  SBBCSD did not converge. See the description of WORK",
       "               above for details."]}},
 "cgeql2"=>
  {"summary"=>
    ["CGEQL2 computes a QL factorization of a complex m by n matrix A:",
     "A = Q * L."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, if m >= n, the lower triangle of the subarray",
       "         A(m-n+1:m,1:n) contains the n by n lower triangular matrix L;",
       "         if m <= n, the elements on and below the (n-m)-th",
       "         superdiagonal contain the m by n lower trapezoidal matrix L;",
       "         the remaining elements, with the array TAU, represent the",
       "         unitary matrix Q as a product of elementary reflectors",
       "         (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "slauu2"=>
  {"summary"=>
    ["SLAUU2 computes the product U * U**T or L**T * L, where the triangular",
     "factor U or L is stored in the upper or lower triangular part of",
     "the array A.",
     "If UPLO = 'U' or 'u' then the upper triangle of the result is stored,",
     "overwriting the factor U in A.",
     "If UPLO = 'L' or 'l' then the lower triangle of the result is stored,",
     "overwriting the factor L in A.",
     "This is the unblocked form of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the triangular factor stored in the array A",
       "         is upper or lower triangular:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the triangular factor U or L.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L.",
       "         On exit, if UPLO = 'U', the upper triangle of A is",
       "         overwritten with the upper triangle of the product U * U**T;",
       "         if UPLO = 'L', the lower triangle of A is overwritten with",
       "         the lower triangle of the product L**T * L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "cgebal"=>
  {"summary"=>
    ["CGEBAL balances a general complex matrix A.  This involves, first,",
     "permuting A by a similarity transformation to isolate eigenvalues",
     "in the first 1 to ILO-1 and last IHI+1 to N elements on the",
     "diagonal; and second, applying a diagonal similarity transformation",
     "to rows and columns ILO to IHI to make the rows and columns as",
     "close in norm as possible.  Both steps are optional.",
     "Balancing may reduce the 1-norm of the matrix, and improve the",
     "accuracy of the computed eigenvalues and/or eigenvectors."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the operations to be performed on A:",
       "         = 'N':  none:  simply set ILO = 1, IHI = N, SCALE(I) = 1.0",
       "                 for i = 1,...,N;",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the input matrix A.",
       "         On exit,  A is overwritten by the balanced matrix.",
       "         If JOB = 'N', A is not referenced.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are set to integers such that on exit",
       "         A(i,j) = 0 if i > j and j = 1,...,ILO-1 or I = IHI+1,...,N.",
       "         If JOB = 'N' or 'S', ILO = 1 and IHI = N."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied to",
       "         A.  If P(j) is the index of the row and column interchanged",
       "         with row and column j and D(j) is the scaling factor",
       "         applied to row and column j, then",
       "         SCALE(j) = P(j)    for j = 1,...,ILO-1",
       "                  = D(j)    for j = ILO,...,IHI",
       "                  = P(j)    for j = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "sorgtr"=>
  {"summary"=>
    ["SORGTR generates a real orthogonal matrix Q which is defined as the",
     "product of n-1 elementary reflectors of order N, as returned by",
     "SSYTRD:",
     "if UPLO = 'U', Q = H(n-1) . . . H(2) H(1),",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(n-1)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangle of A contains elementary reflectors",
       "                from SSYTRD;",
       "         = 'L': Lower triangle of A contains elementary reflectors",
       "                from SSYTRD."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by SSYTRD.",
       "         On exit, the N-by-N orthogonal matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SSYTRD."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N-1).",
       "         For optimum performance LWORK >= (N-1)*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dsposv"=>
  {"summary"=>
    ["DSPOSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite matrix and X and B",
     "are N-by-NRHS matrices.",
     "DSPOSV first attempts to factorize the matrix in SINGLE PRECISION",
     "and use this factorization within an iterative refinement procedure",
     "to produce a solution with DOUBLE PRECISION normwise backward error",
     "quality (see below). If the approach fails the method switches to a",
     "DOUBLE PRECISION factorization and solve.",
     "The iterative refinement is not going to be a winning strategy if",
     "the ratio SINGLE PRECISION performance over DOUBLE PRECISION",
     "performance is too small. A reasonable strategy should take the",
     "number of right-hand sides and the size of the matrix into account.",
     "This might be done with a call to ILAENV in the future. Up to now, we",
     "always try iterative refinement.",
     "The iterative refinement process is stopped if",
     "    ITER > ITERMAX",
     "or for all the RHS we have:",
     "    RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX",
     "where",
     "    o ITER is the number of the current iteration in the iterative",
     "      refinement process",
     "    o RNRM is the infinity-norm of the residual",
     "    o XNRM is the infinity-norm of the solution",
     "    o ANRM is the infinity-operator-norm of the matrix A",
     "    o EPS is the machine epsilon returned by DLAMCH('Epsilon')",
     "The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00",
     "respectively."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array,",
       "         dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if iterative refinement has been successfully used",
       "         (INFO.EQ.0 and ITER.GE.0, see description below), then A is",
       "         unchanged, if double precision factorization has been used",
       "         (INFO.EQ.0 and ITER.LT.0, see description below), then the",
       "         array A contains the factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The N-by-NRHS right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         If INFO = 0, the N-by-NRHS solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (N,NRHS)",
       "         This array is used to hold the residual vectors."],
     "SWORK"=>
      ["[out]",
       "         SWORK is REAL array, dimension (N*(N+NRHS))",
       "         This array is used to use the single precision matrix and the",
       "         right-hand sides or solutions in single precision."],
     "ITER"=>
      ["[out]",
       "         ITER is INTEGER",
       "         < 0: iterative refinement has failed, double precision",
       "              factorization has been performed",
       "              -1 : the routine fell back to full precision for",
       "                   implementation- or machine-specific reasons",
       "              -2 : narrowing the precision induced an overflow,",
       "                   the routine fell back to full precision",
       "              -3 : failure of SPOTRF",
       "              -31: stop the iterative refinement after the 30th",
       "                   iterations",
       "         > 0: iterative refinement has been successfully used.",
       "              Returns the number of iterations"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of (DOUBLE",
       "               PRECISION) A is not positive definite, so the",
       "               factorization could not be completed, and the solution",
       "               has not been computed."]}},
 "ztrti2"=>
  {"summary"=>
    ["ZTRTI2 computes the inverse of a complex upper or lower triangular",
     "matrix.",
     "This is the Level 2 BLAS version of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading n by n upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced.  If DIAG = 'U', the",
       "         diagonal elements of A are also not referenced and are",
       "         assumed to be 1.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "dormr3"=>
  {"summary"=>
    ["DORMR3 overwrites the general real m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**T* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**T if SIDE = 'R' and TRANS = 'C',",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by DTZRZF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left",
       "         = 'R': apply Q or Q**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'T': apply Q**T (Transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing",
       "         the meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DTZRZF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DTZRZF."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "cgbsvx"=>
  {"summary"=>
    ["CGBSVX uses the LU factorization to compute the solution to a complex",
     "system of linear equations A * X = B, A**T * X = B, or A**H * X = B,",
     "where A is a band matrix of order N with KL subdiagonals and KU",
     "superdiagonals, and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "zgeequ"=>
  {"summary"=>
    ["ZGEEQU computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.",
     "R(i) and C(j) are restricted to be between SMLNUM = smallest safe",
     "number and BIGNUM = largest safe number.  Use of these scaling",
     "factors is not guaranteed to reduce the condition number of A but",
     "works well in practice."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The M-by-N matrix whose equilibration factors are",
       "         to be computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is DOUBLE PRECISION",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is DOUBLE PRECISION",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "zheevd_2stage"=>
  {"summary"=>
    ["ZHEEVD_2STAGE computes all eigenvalues and, optionally, eigenvectors of a",
     "complex Hermitian matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  If eigenvectors are desired, it uses a",
     "divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + N+1",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + N+1",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least 2*N + N**2",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array,",
       "                                        dimension (LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If N <= 1,                LRWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LRWORK must be at least N.",
       "         If JOBZ  = 'V' and N > 1, LRWORK must be at least",
       "                        1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i and JOBZ = 'N', then the algorithm failed",
       "               to converge; i off-diagonal elements of an intermediate",
       "               tridiagonal form did not converge to zero;",
       "               if INFO = i and JOBZ = 'V', then the algorithm failed",
       "               to compute an eigenvalue while working on the submatrix",
       "               lying in rows and columns INFO/(N+1) through",
       "               mod(INFO,N+1)."]}},
 "chbgvd"=>
  {"summary"=>
    ["CHBGVD computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite banded eigenproblem, of",
     "the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian",
     "and banded, and B is also positive definite.  If eigenvectors are",
     "desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is COMPLEX array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(kb+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**H*S, as returned by CPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i). The eigenvectors are",
       "         normalized so that Z**H*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO=0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LWORK >= N.",
       "         If JOBZ = 'V' and N > 1, LWORK >= 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO=0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK.",
       "         If N <= 1,               LRWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LRWORK >= N.",
       "         If JOBZ = 'V' and N > 1, LRWORK >= 1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO=0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of array IWORK.",
       "         If JOBZ = 'N' or N <= 1, LIWORK >= 1.",
       "         If JOBZ = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is:",
       "            <= N:  the algorithm failed to converge:",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then CPBSTF",
       "                   returned INFO = i: B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "cgbtf2"=>
  {"summary"=>
    ["CGBTF2 computes an LU factorization of a complex m-by-n band matrix",
     "A using partial pivoting with row interchanges.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(kl+ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = +i, U(i,i) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "ilaver"=>
  {"summary"=>[" This subroutine returns the LAPACK version."], "param"=>nil},
 "dlatps"=>
  {"summary"=>
    ["DLATPS solves one of the triangular systems",
     "   A *x = s*b  or  A**T*x = s*b",
     "with scaling to prevent overflow, where A is an upper or lower",
     "triangular matrix stored in packed form.  Here A**T denotes the",
     "transpose of A, x and b are n-element vectors, and s is a scaling",
     "factor, usually less than or equal to 1, chosen so that the",
     "components of x will be less than the overflow threshold.  If the",
     "unscaled problem will not cause overflow, the Level 2 BLAS routine",
     "DTPSV is called. If the matrix A is singular (A(j,j) = 0 for some j),",
     "then s is set to 0 and a non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b  (No transpose)",
       "         = 'T':  Solve A**T* x = s*b  (Transpose)",
       "         = 'C':  Solve A**T* x = s*b  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b  or  A**T* x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is DOUBLE PRECISION array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "dsterf"=>
  {"summary"=>
    ["DSTERF computes all eigenvalues of a symmetric tridiagonal matrix",
     "using the Pal-Walker-Kahan variant of the QL or QR algorithm."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix.",
       "         On exit, E has been destroyed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  the algorithm failed to find all of the eigenvalues in",
       "               a total of 30*N iterations; if INFO = i, then i",
       "               elements of E have not converged to zero."]}},
 "zggev"=>
  {"summary"=>
    ["ZGGEV computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, and optionally, the left and/or",
     "right generalized eigenvectors.",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right generalized eigenvector v(j) corresponding to the",
     "generalized eigenvalue lambda(j) of (A,B) satisfies",
     "             A * v(j) = lambda(j) * B * v(j).",
     "The left generalized eigenvector u(j) corresponding to the",
     "generalized eigenvalues lambda(j) of (A,B) satisfies",
     "             u(j)**H * A = lambda(j) * u(j)**H * B",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX*16 array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX*16 array, dimension (N)",
       "         On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the",
       "         generalized eigenvalues.",
       "         Note: the quotients ALPHA(j)/BETA(j) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio alpha/beta.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is COMPLEX*16 array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left generalized eigenvectors u(j) are",
       "         stored one after another in the columns of VL, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is COMPLEX*16 array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right generalized eigenvectors v(j) are",
       "         stored one after another in the columns of VR, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,2*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (8*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         =1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHA(j) and BETA(j) should be",
       "               correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other then QZ iteration failed in DHGEQZ,",
       "               =N+2: error return from DTGEVC."]}},
 "dlasr"=>
  {"summary"=>
    ["DLASR applies a sequence of plane rotations to a real matrix A,",
     "from either the left or the right.",
     "When SIDE = 'L', the transformation takes the form",
     "   A := P*A",
     "and when SIDE = 'R', the transformation takes the form",
     "   A := A*P**T",
     "where P is an orthogonal matrix consisting of a sequence of z plane",
     "rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R',",
     "and P**T is the transpose of P.",
     "When DIRECT = 'F' (Forward sequence), then",
     "   P = P(z-1) * ... * P(2) * P(1)",
     "and when DIRECT = 'B' (Backward sequence), then",
     "   P = P(1) * P(2) * ... * P(z-1)",
     "where P(k) is a plane rotation matrix defined by the 2-by-2 rotation",
     "   R(k) = (  c(k)  s(k) )",
     "        = ( -s(k)  c(k) ).",
     "When PIVOT = 'V' (Variable pivot), the rotation is performed",
     "for the plane (k,k+1), i.e., P(k) has the form",
     "   P(k) = (  1                                            )",
     "          (       ...                                     )",
     "          (              1                                )",
     "          (                   c(k)  s(k)                  )",
     "          (                  -s(k)  c(k)                  )",
     "          (                                1              )",
     "          (                                     ...       )",
     "          (                                            1  )",
     "where R(k) appears as a rank-2 modification to the identity matrix in",
     "rows and columns k and k+1.",
     "When PIVOT = 'T' (Top pivot), the rotation is performed for the",
     "plane (1,k+1), so P(k) has the form",
     "   P(k) = (  c(k)                    s(k)                 )",
     "          (         1                                     )",
     "          (              ...                              )",
     "          (                     1                         )",
     "          ( -s(k)                    c(k)                 )",
     "          (                                 1             )",
     "          (                                      ...      )",
     "          (                                             1 )",
     "where R(k) appears in rows and columns 1 and k+1.",
     "Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is",
     "performed for the plane (k,z), giving P(k) the form",
     "   P(k) = ( 1                                             )",
     "          (      ...                                      )",
     "          (             1                                 )",
     "          (                  c(k)                    s(k) )",
     "          (                         1                     )",
     "          (                              ...              )",
     "          (                                     1         )",
     "          (                 -s(k)                    c(k) )",
     "where R(k) appears in rows and columns k and z.  The rotations are",
     "performed without ever forming P(k) explicitly."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         Specifies whether the plane rotation matrix P is applied to",
       "         A on the left or the right.",
       "         = 'L':  Left, compute A := P*A",
       "         = 'R':  Right, compute A:= A*P**T"],
     "PIVOT"=>
      ["[in]",
       "         PIVOT is CHARACTER*1",
       "         Specifies the plane for which P(k) is a plane rotation",
       "         matrix.",
       "         = 'V':  Variable pivot, the plane (k,k+1)",
       "         = 'T':  Top pivot, the plane (1,k+1)",
       "         = 'B':  Bottom pivot, the plane (k,z)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies whether P is a forward or backward sequence of",
       "         plane rotations.",
       "         = 'F':  Forward, P = P(z-1)*...*P(2)*P(1)",
       "         = 'B':  Backward, P = P(1)*P(2)*...*P(z-1)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  If m <= 1, an immediate",
       "         return is effected."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  If n <= 1, an",
       "         immediate return is effected."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension",
       "                 (M-1) if SIDE = 'L'",
       "                 (N-1) if SIDE = 'R'",
       "         The cosines c(k) of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension",
       "                 (M-1) if SIDE = 'L'",
       "                 (N-1) if SIDE = 'R'",
       "         The sines s(k) of the plane rotations.  The 2-by-2 plane",
       "         rotation part of the matrix P(k), R(k), has the form",
       "         R(k) = (  c(k)  s(k) )",
       "                ( -s(k)  c(k) )."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The M-by-N matrix A.  On exit, A is overwritten by P*A if",
       "         SIDE = 'R' or by A*P**T if SIDE = 'L'."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."]}},
 "csptrs"=>
  {"summary"=>
    ["CSPTRS solves a system of linear equations A*X = B with a complex",
     "symmetric matrix A stored in packed format using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by CSPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CSPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSPTRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dggbak"=>
  {"summary"=>
    ["DGGBAK forms the right or left eigenvectors of a real generalized",
     "eigenvalue problem A*x = lambda*B*x, by backward transformation on",
     "the computed eigenvectors of the balanced pair of matrices output by",
     "DGGBAL."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the type of backward transformation required:",
       "         = 'N':  do nothing, return immediately;",
       "         = 'P':  do backward transformation for permutation only;",
       "         = 'S':  do backward transformation for scaling only;",
       "         = 'B':  do backward transformations for both permutation and",
       "                 scaling.",
       "         JOB must be the same as the argument JOB supplied to DGGBAL."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  V contains right eigenvectors;",
       "         = 'L':  V contains left eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrix V.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         The integers ILO and IHI determined by DGGBAL.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "LSCALE"=>
      ["[in]",
       "         LSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and/or scaling factors applied",
       "         to the left side of A and B, as returned by DGGBAL."],
     "RSCALE"=>
      ["[in]",
       "         RSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and/or scaling factors applied",
       "         to the right side of A and B, as returned by DGGBAL."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix V.  M >= 0."],
     "V"=>
      ["[in,out]",
       "         V is DOUBLE PRECISION array, dimension (LDV,M)",
       "         On entry, the matrix of right or left eigenvectors to be",
       "         transformed, as returned by DTGEVC.",
       "         On exit, V is overwritten by the transformed eigenvectors."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the matrix V. LDV >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zhbevx"=>
  {"summary"=>
    ["ZHBEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian band matrix A.  Eigenvalues and eigenvectors",
     "can be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX*16 array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the N-by-N unitary matrix used in the",
       "                         reduction to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'V', then",
       "         LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AB to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "sgemqr"=>
  {"summary"=>
    ["SGEMQR overwrites the general real M-by-N matrix C with",
     "                     SIDE = 'L'     SIDE = 'R'",
     "    TRANS = 'N':      Q * C          C * Q",
     "    TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product",
     "of blocked elementary reflectors computed by tall skinny",
     "QR factorization (SGEQR)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,K)",
       "         Part of the data structure to represent Q as returned by SGEQR."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (MAX(5,TSIZE)).",
       "         Part of the data structure to represent Q as returned by SGEQR."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         The dimension of the array T. TSIZE >= 5."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]", "        (workspace) REAL array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed. The routine",
       "         only calculates the size of the WORK array, returns this",
       "         value as WORK(1), and no error message related to WORK ",
       "         is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgeequb"=>
  {"summary"=>
    ["ZGEEQUB computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most",
     "the radix.",
     "R(i) and C(j) are restricted to be a power of the radix between",
     "SMLNUM = smallest safe number and BIGNUM = largest safe number.  Use",
     "of these scaling factors is not guaranteed to reduce the condition",
     "number of A but works well in practice.",
     "This routine differs from ZGEEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled entries' magnitudes are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The M-by-N matrix whose equilibration factors are",
       "         to be computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is DOUBLE PRECISION",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is DOUBLE PRECISION",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "sposv"=>
  {"summary"=>
    ["SPOSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite matrix and X and B",
     "are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**T* U,  if UPLO = 'U', or",
     "   A = L * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is a lower triangular",
     "matrix.  The factored form of A is then used to solve the system of",
     "equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "dsptrd"=>
  {"summary"=>
    ["DSPTRD reduces a real symmetric matrix A stored in packed form to",
     "symmetric tridiagonal form T by an orthogonal similarity",
     "transformation: Q**T * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the orthogonal",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the orthogonal matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgsvj0"=>
  {"summary"=>
    ["CGSVJ0 is called from CGESVJ as a pre-processor and that is its main",
     "purpose. It applies Jacobi rotations in the same way as CGESVJ does, but",
     "it does not check convergence (stopping criterion). Few tuning",
     "parameters (marked by [TP]) are available for the implementer."],
   "param"=>
    {"JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether the output from this procedure is used",
       "         to compute the matrix V:",
       "         = 'V': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the N-by-N array V.",
       "               (See the description of V.)",
       "         = 'A': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the MV-by-N array V.",
       "               (See the descriptions of MV and V.)",
       "         = 'N': the Jacobi rotations are not accumulated."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, M-by-N matrix A, such that A*diag(D) represents",
       "         the input matrix.",
       "         On exit,",
       "         A_onexit * diag(D_onexit) represents the input matrix A*diag(D)",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of D, TOL and NSWEEP.)"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX array, dimension (N)",
       "         The array D accumulates the scaling factors from the complex scaled",
       "         Jacobi rotations.",
       "         On entry, A*diag(D) represents the input matrix.",
       "         On exit, A_onexit*diag(D_onexit) represents the input matrix",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of A, TOL and NSWEEP.)"],
     "SVA"=>
      ["[in,out]",
       "         SVA is REAL array, dimension (N)",
       "         On entry, SVA contains the Euclidean norms of the columns of",
       "         the matrix A*diag(D).",
       "         On exit, SVA contains the Euclidean norms of the columns of",
       "         the matrix A_onexit*diag(D_onexit)."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then MV is not referenced."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX array, dimension (LDV,N)",
       "         If JOBV .EQ. 'V' then N rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV .EQ. 'A' then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V', LDV .GE. N.",
       "         If JOBV = 'A', LDV .GE. MV."],
     "EPS"=>
      ["[in]", "         EPS is REAL", "         EPS = SLAMCH('Epsilon')"],
     "SFMIN"=>
      ["[in]",
       "         SFMIN is REAL",
       "         SFMIN = SLAMCH('Safe Minimum')"],
     "TOL"=>
      ["[in]",
       "         TOL is REAL",
       "         TOL is the threshold for Jacobi rotations. For a pair",
       "         A(:,p), A(:,q) of pivot columns, the Jacobi rotation is",
       "         applied only if ABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL."],
     "NSWEEP"=>
      ["[in]",
       "         NSWEEP is INTEGER",
       "         NSWEEP is the number of sweeps of Jacobi rotations to be",
       "         performed."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         LWORK is the dimension of WORK. LWORK .GE. M."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value"]}},
 "ilaprec"=>
  {"summary"=>
    ["This subroutine translated from a character string specifying an",
     "intermediate precision to the relevant BLAST-specified integer",
     "constant.",
     "ILAPREC returns an INTEGER.  If ILAPREC < 0, then the input is not a",
     "character indicating a supported intermediate precision.  Otherwise",
     "ILAPREC returns the constant value corresponding to PREC."],
   "param"=>nil},
 "ztrcon"=>
  {"summary"=>
    ["ZTRCON estimates the reciprocal of the condition number of a",
     "triangular matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlasq2"=>
  {"summary"=>
    ["DLASQ2 computes all the eigenvalues of the symmetric positive",
     "definite tridiagonal matrix associated with the qd array Z to high",
     "relative accuracy are computed to high relative accuracy, in the",
     "absence of denormalization, underflow and overflow.",
     "To see the relation of Z to the tridiagonal matrix, let L be a",
     "unit lower bidiagonal matrix with subdiagonals Z(2,4,6,,..) and",
     "let U be an upper bidiagonal matrix with 1's above and diagonal",
     "Z(1,3,5,,..). The tridiagonal is L*U or, if you prefer, the",
     "symmetric tridiagonal to which it is similar.",
     "Note : DLASQ2 defines a logical variable, IEEE, which is true",
     "on machines which follow ieee-754 floating-point standard in their",
     "handling of infinities and NaNs, and false otherwise. This variable",
     "is passed to DLASQ3."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "       The number of rows and columns in the matrix. N >= 0."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension ( 4*N )",
       "       On entry Z holds the qd array. On exit, entries 1 to N hold",
       "       the eigenvalues in decreasing order, Z( 2*N+1 ) holds the",
       "       trace, and Z( 2*N+2 ) holds the sum of the eigenvalues. If",
       "       N > 2, then Z( 2*N+3 ) holds the iteration count, Z( 2*N+4 )",
       "       holds NDIVS/NIN^2, and Z( 2*N+5 ) holds the percentage of",
       "       shifts that failed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "       = 0: successful exit",
       "       < 0: if the i-th argument is a scalar and had an illegal",
       "            value, then INFO = -i, if the i-th argument is an",
       "            array and the j-entry had an illegal value, then",
       "            INFO = -(i*100+j)",
       "       > 0: the algorithm failed",
       "             = 1, a split was marked by a positive value in E",
       "             = 2, current block of Z not diagonalized after 100*N",
       "                  iterations (in inner while loop).  On exit Z holds",
       "                  a qd array with the same eigenvalues as the given Z.",
       "             = 3, termination criterion of outer while loop not met",
       "                  (program created more than N unreduced blocks)"]}},
 "sorm2l"=>
  {"summary"=>
    ["SORM2L overwrites the general real m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**T * C  if SIDE = 'L' and TRANS = 'T', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**T if SIDE = 'R' and TRANS = 'T',",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by SGEQLF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left",
       "         = 'R': apply Q or Q**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'T': apply Q**T (Transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         SGEQLF in the last k columns of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGEQLF."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dopgtr"=>
  {"summary"=>
    ["DOPGTR generates a real orthogonal matrix Q which is defined as the",
     "product of n-1 elementary reflectors H(i) of order n, as returned by",
     "DSPTRD using packed storage:",
     "if UPLO = 'U', Q = H(n-1) . . . H(2) H(1),",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(n-1)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangular packed storage used in previous",
       "                call to DSPTRD;",
       "         = 'L': Lower triangular packed storage used in previous",
       "                call to DSPTRD."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The vectors which define the elementary reflectors, as",
       "         returned by DSPTRD."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DSPTRD."],
     "Q"=>
      ["[out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         The N-by-N orthogonal matrix Q."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N-1)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chbgv"=>
  {"summary"=>
    ["CHBGV computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite banded eigenproblem, of",
     "the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian",
     "and banded, and B is also positive definite."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is COMPLEX array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(kb+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**H*S, as returned by CPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i). The eigenvectors are",
       "         normalized so that Z**H*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= N."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is:",
       "            <= N:  the algorithm failed to converge:",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then CPBSTF",
       "                   returned INFO = i: B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "dlasd0"=>
  {"summary"=>
    ["Using a divide and conquer approach, DLASD0 computes the singular",
     "value decomposition (SVD) of a real upper bidiagonal N-by-M",
     "matrix B with diagonal D and offdiagonal E, where M = N + SQRE.",
     "The algorithm computes orthogonal matrices U and VT such that",
     "B = U * S * VT. The singular values S are overwritten on D.",
     "A related subroutine, DLASDA, computes only the singular values,",
     "and optionally, the singular vectors in compact form."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        On entry, the row dimension of the upper bidiagonal matrix.",
       "        This is also the dimension of the main diagonal array D."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        Specifies the column dimension of the bidiagonal matrix.",
       "        = 0: The bidiagonal matrix has column dimension M = N;",
       "        = 1: The bidiagonal matrix has column dimension M = N+1;"],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        On entry D contains the main diagonal of the bidiagonal",
       "        matrix.",
       "        On exit D, if INFO = 0, contains its singular values."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (M-1)",
       "        Contains the subdiagonal entries of the bidiagonal matrix.",
       "        On exit, E has been destroyed."],
     "U"=>
      ["[out]",
       "         U is DOUBLE PRECISION array, dimension at least (LDQ, N)",
       "        On exit, U contains the left singular vectors."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "        On entry, leading dimension of U."],
     "VT"=>
      ["[out]",
       "         VT is DOUBLE PRECISION array, dimension at least (LDVT, M)",
       "        On exit, VT**T contains the right singular vectors."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "        On entry, leading dimension of VT."],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        On entry, maximum size of the subproblems at the",
       "        bottom of the computation tree."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER work array.",
       "        Dimension must be at least (8 * N)"],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION work array.",
       "        Dimension must be at least (3 * M**2 + 2 * M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, a singular value did not converge"]}},
 "dlapmr"=>
  {"summary"=>
    ["DLAPMR rearranges the rows of the M by N matrix X as specified",
     "by the permutation K(1),K(2),...,K(M) of the integers 1,...,M.",
     "If FORWRD = .TRUE.,  forward permutation:",
     "     X(K(I),*) is moved X(I,*) for I = 1,2,...,M.",
     "If FORWRD = .FALSE., backward permutation:",
     "     X(I,*) is moved to X(K(I),*) for I = 1,2,...,M."],
   "param"=>
    {"FORWRD"=>
      ["[in]",
       "         FORWRD is LOGICAL",
       "         = .TRUE., forward permutation",
       "         = .FALSE., backward permutation"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix X. N >= 0."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,N)",
       "         On entry, the M by N matrix X.",
       "         On exit, X contains the permuted matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X, LDX >= MAX(1,M)."],
     "K"=>
      ["[in,out]",
       "         K is INTEGER array, dimension (M)",
       "         On entry, K contains the permutation vector. K is used as",
       "         internal workspace, but reset to its original value on",
       "         output."]}},
 "zunm2r"=>
  {"summary"=>
    ["ZUNM2R overwrites the general complex m-by-n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**H* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**H if SIDE = 'R' and TRANS = 'C',",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by ZGEQRF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left",
       "         = 'R': apply Q or Q**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         ZGEQRF in the first k columns of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGEQRF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zhptrd"=>
  {"summary"=>
    ["ZHPTRD reduces a complex Hermitian matrix A stored in packed form to",
     "real symmetric tridiagonal form T by a unitary similarity",
     "transformation: Q**H * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the unitary",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the unitary matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgelsy"=>
  {"summary"=>
    ["SGELSY computes the minimum-norm solution to a real linear least",
     "squares problem:",
     "    minimize || A * X - B ||",
     "using a complete orthogonal factorization of A.  A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X.",
     "The routine first computes a QR factorization with column pivoting:",
     "    A * P = Q * [ R11 R12 ]",
     "                [  0  R22 ]",
     "with R11 defined as the largest leading submatrix whose estimated",
     "condition number is less than 1/RCOND.  The order of R11, RANK,",
     "is the effective rank of A.",
     "Then, R22 is considered to be negligible, and R12 is annihilated",
     "by orthogonal transformations from the right, arriving at the",
     "complete orthogonal factorization:",
     "   A * P = Q * [ T11 0 ] * Z",
     "               [  0  0 ]",
     "The minimum-norm solution is then",
     "   X = P * Z**T [ inv(T11)*Q1**T*B ]",
     "                [        0         ]",
     "where Q1 consists of the first RANK columns of Q.",
     "This routine is basically identical to the original xGELSX except",
     "three differences:",
     "  o The call to the subroutine xGEQPF has been substituted by the",
     "    the call to the subroutine xGEQP3. This subroutine is a Blas-3",
     "    version of the QR factorization with column pivoting.",
     "  o Matrix B (the right hand side) is updated with Blas-3.",
     "  o The permutation of matrix B (the right hand side) is faster and",
     "    more simple."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A has been overwritten by details of its",
       "         complete orthogonal factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,M,N)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(i) .ne. 0, the i-th column of A is permuted",
       "         to the front of AP, otherwise column i is a free column.",
       "         On exit, if JPVT(i) = k, then the i-th column of AP",
       "         was the k-th column of A."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "         RCOND is used to determine the effective rank of A, which",
       "         is defined as the order of the largest leading triangular",
       "         submatrix R11 in the QR factorization with pivoting of A,",
       "         whose estimated condition number < 1/RCOND."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the order of the submatrix",
       "         R11.  This is the same as the order of the submatrix T11",
       "         in the complete orthogonal factorization of A."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         The unblocked strategy requires that:",
       "            LWORK >= MAX( MN+3*N+1, 2*MN+NRHS ),",
       "         where MN = min( M, N ).",
       "         The block algorithm requires that:",
       "            LWORK >= MAX( MN+2*N+NB*(N+1), 2*MN+NB*NRHS ),",
       "         where NB is an upper bound on the blocksize returned",
       "         by ILAENV for the routines SGEQP3, STZRZF, STZRQF, SORMQR,",
       "         and SORMRZ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -i, the i-th argument had an illegal value."]}},
 "ztrexc"=>
  {"summary"=>
    ["ZTREXC reorders the Schur factorization of a complex matrix",
     "A = Q*T*Q**H, so that the diagonal element of T with row index IFST",
     "is moved to row ILST.",
     "The Schur form T is reordered by a unitary similarity transformation",
     "Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by",
     "postmultplying it with Z."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'V':  update the matrix Q of Schur vectors;",
       "         = 'N':  do not update Q."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0.",
       "         If N == 0 arguments ILST and IFST may be any value."],
     "T"=>
      ["[in,out]",
       "         T is COMPLEX*16 array, dimension (LDT,N)",
       "         On entry, the upper triangular matrix T.",
       "         On exit, the reordered upper triangular matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,N)",
       "         On entry, if COMPQ = 'V', the matrix Q of Schur vectors.",
       "         On exit, if COMPQ = 'V', Q has been postmultiplied by the",
       "         unitary transformation matrix Z which reorders T.",
       "         If COMPQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= 1, and if",
       "         COMPQ = 'V', LDQ >= max(1,N)."],
     "IFST"=>["[in]", "         IFST is INTEGER"],
     "ILST"=>
      ["[in]",
       "         ILST is INTEGER",
       "         Specify the reordering of the diagonal elements of T:",
       "         The element with row index IFST is moved to row ILST by a",
       "         sequence of transpositions between adjacent elements.",
       "         1 <= IFST <= N; 1 <= ILST <= N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlasr"=>
  {"summary"=>
    ["ZLASR applies a sequence of real plane rotations to a complex matrix",
     "A, from either the left or the right.",
     "When SIDE = 'L', the transformation takes the form",
     "   A := P*A",
     "and when SIDE = 'R', the transformation takes the form",
     "   A := A*P**T",
     "where P is an orthogonal matrix consisting of a sequence of z plane",
     "rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R',",
     "and P**T is the transpose of P.",
     "When DIRECT = 'F' (Forward sequence), then",
     "   P = P(z-1) * ... * P(2) * P(1)",
     "and when DIRECT = 'B' (Backward sequence), then",
     "   P = P(1) * P(2) * ... * P(z-1)",
     "where P(k) is a plane rotation matrix defined by the 2-by-2 rotation",
     "   R(k) = (  c(k)  s(k) )",
     "        = ( -s(k)  c(k) ).",
     "When PIVOT = 'V' (Variable pivot), the rotation is performed",
     "for the plane (k,k+1), i.e., P(k) has the form",
     "   P(k) = (  1                                            )",
     "          (       ...                                     )",
     "          (              1                                )",
     "          (                   c(k)  s(k)                  )",
     "          (                  -s(k)  c(k)                  )",
     "          (                                1              )",
     "          (                                     ...       )",
     "          (                                            1  )",
     "where R(k) appears as a rank-2 modification to the identity matrix in",
     "rows and columns k and k+1.",
     "When PIVOT = 'T' (Top pivot), the rotation is performed for the",
     "plane (1,k+1), so P(k) has the form",
     "   P(k) = (  c(k)                    s(k)                 )",
     "          (         1                                     )",
     "          (              ...                              )",
     "          (                     1                         )",
     "          ( -s(k)                    c(k)                 )",
     "          (                                 1             )",
     "          (                                      ...      )",
     "          (                                             1 )",
     "where R(k) appears in rows and columns 1 and k+1.",
     "Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is",
     "performed for the plane (k,z), giving P(k) the form",
     "   P(k) = ( 1                                             )",
     "          (      ...                                      )",
     "          (             1                                 )",
     "          (                  c(k)                    s(k) )",
     "          (                         1                     )",
     "          (                              ...              )",
     "          (                                     1         )",
     "          (                 -s(k)                    c(k) )",
     "where R(k) appears in rows and columns k and z.  The rotations are",
     "performed without ever forming P(k) explicitly."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         Specifies whether the plane rotation matrix P is applied to",
       "         A on the left or the right.",
       "         = 'L':  Left, compute A := P*A",
       "         = 'R':  Right, compute A:= A*P**T"],
     "PIVOT"=>
      ["[in]",
       "         PIVOT is CHARACTER*1",
       "         Specifies the plane for which P(k) is a plane rotation",
       "         matrix.",
       "         = 'V':  Variable pivot, the plane (k,k+1)",
       "         = 'T':  Top pivot, the plane (1,k+1)",
       "         = 'B':  Bottom pivot, the plane (k,z)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies whether P is a forward or backward sequence of",
       "         plane rotations.",
       "         = 'F':  Forward, P = P(z-1)*...*P(2)*P(1)",
       "         = 'B':  Backward, P = P(1)*P(2)*...*P(z-1)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  If m <= 1, an immediate",
       "         return is effected."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  If n <= 1, an",
       "         immediate return is effected."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension",
       "                 (M-1) if SIDE = 'L'",
       "                 (N-1) if SIDE = 'R'",
       "         The cosines c(k) of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension",
       "                 (M-1) if SIDE = 'L'",
       "                 (N-1) if SIDE = 'R'",
       "         The sines s(k) of the plane rotations.  The 2-by-2 plane",
       "         rotation part of the matrix P(k), R(k), has the form",
       "         R(k) = (  c(k)  s(k) )",
       "                ( -s(k)  c(k) )."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The M-by-N matrix A.  On exit, A is overwritten by P*A if",
       "         SIDE = 'R' or by A*P**T if SIDE = 'L'."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."]}},
 "chpsv"=>
  {"summary"=>
    ["CHPSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian matrix stored in packed format and X",
     "and B are N-by-NRHS matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**H,  if UPLO = 'U', or",
     "   A = L * D * L**H,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, D is Hermitian and block diagonal with 1-by-1",
     "and 2-by-2 diagonal blocks.  The factored form of A is then used to",
     "solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L from the factorization",
       "         A = U*D*U**H or A = L*D*L**H as computed by CHPTRF, stored as",
       "         a packed triangular matrix in the same storage format as A."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by CHPTRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, so the solution could not be",
       "               computed."]}},
 "dgemqr"=>
  {"summary"=>
    ["DGEMQR overwrites the general real M-by-N matrix C with",
     "                     SIDE = 'L'     SIDE = 'R'",
     "     TRANS = 'N':      Q * C          C * Q",
     "     TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product",
     "of blocked elementary reflectors computed by tall skinny",
     "QR factorization (DGEQR)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,K)",
       "         Part of the data structure to represent Q as returned by DGEQR."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (MAX(5,TSIZE)).",
       "         Part of the data structure to represent Q as returned by DGEQR."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         The dimension of the array T. TSIZE >= 5."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "        (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed. The routine",
       "         only calculates the size of the WORK array, returns this",
       "         value as WORK(1), and no error message related to WORK ",
       "         is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cunmr3"=>
  {"summary"=>
    ["CUNMR3 overwrites the general complex m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**H* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**H if SIDE = 'R' and TRANS = 'C',",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by CTZRZF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left",
       "         = 'R': apply Q or Q**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing",
       "         the meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CTZRZF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CTZRZF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dlatrz"=>
  {"summary"=>
    ["DLATRZ factors the M-by-(M+L) real upper trapezoidal matrix",
     "[ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R  0 ) * Z, by means",
     "of orthogonal transformations.  Z is an (M+L)-by-(M+L) orthogonal",
     "matrix and, R and A1 are M-by-M upper triangular matrices."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing the",
       "         meaningful part of the Householder vectors. N-M >= L >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the leading M-by-N upper trapezoidal part of the",
       "         array A must contain the matrix to be factorized.",
       "         On exit, the leading M-by-M upper triangular part of A",
       "         contains the upper triangular matrix R, and elements N-L+1 to",
       "         N of the first M rows of A, with the array TAU, represent the",
       "         orthogonal matrix Z as a product of M elementary reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (M)",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (M)"]}},
 "zla_syrcond_c"=>
  {"summary"=>
    ["   ZLA_SYRCOND_C Computes the infinity norm condition number of",
     "   op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by ZSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by ZSYTRF."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The vector C in the formula op(A) * inv(diag(C))."],
     "CAPPLY"=>
      ["[in]",
       "         CAPPLY is LOGICAL",
       "    If .TRUE. then access the vector C in the formula above."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX*16 array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is DOUBLE PRECISION array, dimension (N).",
       "    Workspace."]}},
 "dgtsv"=>
  {"summary"=>
    ["DGTSV  solves the equation",
     "   A*X = B,",
     "where A is an n by n tridiagonal matrix, by Gaussian elimination with",
     "partial pivoting.",
     "Note that the equation  A**T*X = B  may be solved by interchanging the",
     "order of the arguments DU and DL."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in,out]",
       "         DL is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, DL must contain the (n-1) sub-diagonal elements of",
       "         A.",
       "         On exit, DL is overwritten by the (n-2) elements of the",
       "         second super-diagonal of the upper triangular matrix U from",
       "         the LU factorization of A, in DL(1), ..., DL(n-2)."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, D must contain the diagonal elements of A.",
       "         On exit, D is overwritten by the n diagonal elements of U."],
     "DU"=>
      ["[in,out]",
       "         DU is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, DU must contain the (n-1) super-diagonal elements",
       "         of A.",
       "         On exit, DU is overwritten by the (n-1) elements of the first",
       "         super-diagonal of U."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N by NRHS matrix of right hand side matrix B.",
       "         On exit, if INFO = 0, the N by NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, U(i,i) is exactly zero, and the solution",
       "              has not been computed.  The factorization has not been",
       "              completed unless i = N."]}},
 "ztrtri"=>
  {"summary"=>
    ["ZTRTRI computes the inverse of a complex upper or lower triangular",
     "matrix A.",
     "This is the Level 3 BLAS version of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced.  If DIAG = 'U', the",
       "         diagonal elements of A are also not referenced and are",
       "         assumed to be 1.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, A(i,i) is exactly zero.  The triangular",
       "              matrix is singular and its inverse can not be computed."]}},
 "dlarzb"=>
  {"summary"=>
    ["DLARZB applies a real block reflector H or its transpose H**T to",
     "a real distributed M-by-N  C from the left or the right.",
     "Currently, only STOREV = 'R' and DIRECT = 'B' are supported."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H**T from the Left",
       "         = 'R': apply H or H**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'C': apply H**T (Transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columnwise                        (not supported yet)",
       "         = 'R': Rowwise"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T (= the number of elementary",
       "         reflectors whose product defines the block reflector)."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix V containing the",
       "         meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension (LDV,NV).",
       "         If STOREV = 'C', NV = K; if STOREV = 'R', NV = L."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= L; if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (LDT,K)",
       "         The triangular K-by-K matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LDWORK,K)"],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= max(1,N);",
       "         if SIDE = 'R', LDWORK >= max(1,M)."]}},
 "cgesvdx"=>
  {"summary"=>
    [" CGESVDX computes the singular value decomposition (SVD) of a complex",
     " M-by-N matrix A, optionally computing the left and/or right singular",
     " vectors. The SVD is written",
     "     A = U * SIGMA * transpose(V)",
     " where SIGMA is an M-by-N matrix which is zero except for its",
     " min(m,n) diagonal elements, U is an M-by-M unitary matrix, and",
     " V is an N-by-N unitary matrix.  The diagonal elements of SIGMA",
     " are the singular values of A; they are real and non-negative, and",
     " are returned in descending order.  The first min(m,n) columns of",
     " U and V are the left and right singular vectors of A.",
     " CGESVDX uses an eigenvalue problem for obtaining the SVD, which",
     " allows for the computation of a subset of singular values and",
     " vectors. See SBDSVDX for details.",
     " Note that the routine returns V**T, not V."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'V':  the first min(m,n) columns of U (the left singular",
       "                 vectors) or as specified by RANGE are returned in",
       "                 the array U;",
       "         = 'N':  no columns of U (no left singular vectors) are",
       "                 computed."],
     "JOBVT"=>
      ["[in]",
       "         JOBVT is CHARACTER*1",
       "          Specifies options for computing all or part of the matrix",
       "          V**T:",
       "          = 'V':  the first min(m,n) rows of V**T (the right singular",
       "                  vectors) or as specified by RANGE are returned in",
       "                  the array VT;",
       "          = 'N':  no rows of V**T (no right singular vectors) are",
       "                  computed."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all singular values will be found.",
       "         = 'V': all singular values in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th singular values will be found."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the contents of A are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "NS"=>
      ["[out]",
       "         NS is INTEGER",
       "         The total number of singular values found,",
       "         0 <= NS <= min(M,N).",
       "         If RANGE = 'A', NS = min(M,N); if RANGE = 'I', NS = IU-IL+1."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is COMPLEX array, dimension (LDU,UCOL)",
       "         If JOBU = 'V', U contains columns of U (the left singular",
       "         vectors, stored columnwise) as specified by RANGE; if",
       "         JOBU = 'N', U is not referenced.",
       "         Note: The user must ensure that UCOL >= NS; if RANGE = 'V',",
       "         the exact value of NS is not known in advance and an upper",
       "         bound must be used."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1; if",
       "         JOBU = 'V', LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is COMPLEX array, dimension (LDVT,N)",
       "         If JOBVT = 'V', VT contains the rows of V**T (the right singular",
       "         vectors, stored rowwise) as specified by RANGE; if JOBVT = 'N',",
       "         VT is not referenced.",
       "         Note: The user must ensure that LDVT >= NS; if RANGE = 'V',",
       "         the exact value of NS is not known in advance and an upper",
       "         bound must be used."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1; if",
       "         JOBVT = 'V', LDVT >= NS (see above)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK;"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= MAX(1,MIN(M,N)*(MIN(M,N)+4)) for the paths (see",
       "         comments inside the code):",
       "            - PATH 1  (M much larger than N)",
       "            - PATH 1t (N much larger than M)",
       "         LWORK >= MAX(1,MIN(M,N)*2+MAX(M,N)) for the other paths.",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         LRWORK >= MIN(M,N)*(MIN(M,N)*2+15*MIN(M,N))."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (12*MIN(M,N))",
       "         If INFO = 0, the first NS elements of IWORK are zero. If INFO > 0,",
       "         then IWORK contains the indices of the eigenvectors that failed",
       "         to converge in SBDSVDX/SSTEVX."],
     "INFO"=>
      ["[out]",
       "    INFO is INTEGER",
       "          = 0:  successful exit",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value",
       "          > 0:  if INFO = i, then i eigenvectors failed to converge",
       "                in SBDSVDX/SSTEVX.",
       "                if INFO = N*2 + 1, an internal error occurred in",
       "                SBDSVDX"]}},
 "dgebal"=>
  {"summary"=>
    ["DGEBAL balances a general real matrix A.  This involves, first,",
     "permuting A by a similarity transformation to isolate eigenvalues",
     "in the first 1 to ILO-1 and last IHI+1 to N elements on the",
     "diagonal; and second, applying a diagonal similarity transformation",
     "to rows and columns ILO to IHI to make the rows and columns as",
     "close in norm as possible.  Both steps are optional.",
     "Balancing may reduce the 1-norm of the matrix, and improve the",
     "accuracy of the computed eigenvalues and/or eigenvectors."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the operations to be performed on A:",
       "         = 'N':  none:  simply set ILO = 1, IHI = N, SCALE(I) = 1.0",
       "                 for i = 1,...,N;",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE array, dimension (LDA,N)",
       "         On entry, the input matrix A.",
       "         On exit,  A is overwritten by the balanced matrix.",
       "         If JOB = 'N', A is not referenced.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are set to integers such that on exit",
       "         A(i,j) = 0 if i > j and j = 1,...,ILO-1 or I = IHI+1,...,N.",
       "         If JOB = 'N' or 'S', ILO = 1 and IHI = N."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE array, dimension (N)",
       "         Details of the permutations and scaling factors applied to",
       "         A.  If P(j) is the index of the row and column interchanged",
       "         with row and column j and D(j) is the scaling factor",
       "         applied to row and column j, then",
       "         SCALE(j) = P(j)    for j = 1,...,ILO-1",
       "                  = D(j)    for j = ILO,...,IHI",
       "                  = P(j)    for j = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "clanhf"=>
  {"summary"=>
    ["CLANHF  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex Hermitian matrix A in RFP format.",
     "   CLANHF = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a  matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER",
       "           Specifies the value to be returned in CLANHF as described",
       "           above."],
     "TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER",
       "           Specifies whether the RFP format of A is normal or",
       "           conjugate-transposed format.",
       "           = 'N':  RFP format is Normal",
       "           = 'C':  RFP format is Conjugate-transposed"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER",
       "           On entry, UPLO specifies whether the RFP matrix A came from",
       "           an upper or lower triangular matrix as follows:",
       "           UPLO = 'U' or 'u' RFP A came from an upper triangular",
       "           matrix",
       "           UPLO = 'L' or 'l' RFP A came from a  lower triangular",
       "           matrix"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "           The order of the matrix A.  N >= 0.  When N = 0, CLANHF is",
       "           set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension ( N*(N+1)/2 );",
       "           On entry, the matrix A in RFP Format.",
       "           RFP Format is described by TRANSR, UPLO and N as follows:",
       "           If TRANSR='N' then RFP A is (0:N,0:K-1) when N is even;",
       "           K=N/2. RFP A is (0:N-1,0:K) when N is odd; K=N/2. If",
       "           TRANSR = 'C' then RFP is the Conjugate-transpose of RFP A",
       "           as defined when TRANSR = 'N'. The contents of RFP A are",
       "           defined by UPLO as follows: If UPLO = 'U' the RFP A",
       "           contains the ( N*(N+1)/2 ) elements of upper packed A",
       "           either in normal or conjugate-transpose Format. If",
       "           UPLO = 'L' the RFP A contains the ( N*(N+1) /2 ) elements",
       "           of lower packed A either in normal or conjugate-transpose",
       "           Format. The LDA of RFP A is (N+1)/2 when TRANSR = 'C'. When",
       "           TRANSR is 'N' the LDA is N+1 when N is even and is N when",
       "           is odd. See the Note below for more details.",
       "           Unchanged on exit."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (LWORK),",
       "           where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "           WORK is not referenced."]}},
 "sstebz"=>
  {"summary"=>
    ["SSTEBZ computes the eigenvalues of a symmetric tridiagonal",
     "matrix T.  The user may ask for all eigenvalues, all eigenvalues",
     "in the half-open interval (VL, VU], or the IL-th through IU-th",
     "eigenvalues.",
     "To avoid overflow, the matrix must be scaled so that its",
     "largest element is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest",
     "accuracy, it should not be much smaller than that.",
     "See W. Kahan \"Accurate Eigenvalues of a Symmetric Tridiagonal",
     "Matrix\", Report CS41, Computer Science Dept., Stanford",
     "University, July 21, 1966."],
   "param"=>
    {"RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': (\"All\")   all eigenvalues will be found.",
       "         = 'V': (\"Value\") all eigenvalues in the half-open interval",
       "                          (VL, VU] will be found.",
       "         = 'I': (\"Index\") the IL-th through IU-th eigenvalues (of the",
       "                          entire matrix) will be found."],
     "ORDER"=>
      ["[in]",
       "         ORDER is CHARACTER*1",
       "         = 'B': (\"By Block\") the eigenvalues will be grouped by",
       "                             split-off block (see IBLOCK, ISPLIT) and",
       "                             ordered from smallest to largest within",
       "                             the block.",
       "         = 'E': (\"Entire matrix\")",
       "                             the eigenvalues for the entire matrix",
       "                             will be ordered from smallest to",
       "                             largest."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix T.  N >= 0."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues.  Eigenvalues less than or equal",
       "         to VL, or greater than VU, will not be returned.  VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues.  Eigenvalues less than or equal",
       "         to VL, or greater than VU, will not be returned.  VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute tolerance for the eigenvalues.  An eigenvalue",
       "         (or cluster) is considered to be located if it has been",
       "         determined to lie in an interval whose width is ABSTOL or",
       "         less.  If ABSTOL is less than or equal to zero, then ULP*|T|",
       "         will be used, where |T| means the 1-norm of T.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the tridiagonal matrix T."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The actual number of eigenvalues found. 0 <= M <= N.",
       "         (See also the description of INFO=2,3.)"],
     "NSPLIT"=>
      ["[out]",
       "         NSPLIT is INTEGER",
       "         The number of diagonal blocks in the matrix T.",
       "         1 <= NSPLIT <= N."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         On exit, the first M elements of W will contain the",
       "         eigenvalues.  (SSTEBZ may use the remaining N-M elements as",
       "         workspace.)"],
     "IBLOCK"=>
      ["[out]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         At each row/column j where E(j) is zero or small, the",
       "         matrix T is considered to split into a block diagonal",
       "         matrix.  On exit, if INFO = 0, IBLOCK(i) specifies to which",
       "         block (from 1 to the number of blocks) the eigenvalue W(i)",
       "         belongs.  (SSTEBZ may use the remaining N-M elements as",
       "         workspace.)"],
     "ISPLIT"=>
      ["[out]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into submatrices.",
       "         The first submatrix consists of rows/columns 1 to ISPLIT(1),",
       "         the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),",
       "         etc., and the NSPLIT-th consists of rows/columns",
       "         ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.",
       "         (Only the first NSPLIT elements will actually be used, but",
       "         since the user cannot know a priori what value NSPLIT will",
       "         have, N words must be reserved for ISPLIT.)"],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  some or all of the eigenvalues failed to converge or",
       "               were not computed:",
       "               =1 or 3: Bisection failed to converge for some",
       "                       eigenvalues; these eigenvalues are flagged by a",
       "                       negative block number.  The effect is that the",
       "                       eigenvalues may not be as accurate as the",
       "                       absolute and relative tolerances.  This is",
       "                       generally caused by unexpectedly inaccurate",
       "                       arithmetic.",
       "               =2 or 3: RANGE='I' only: Not all of the eigenvalues",
       "                       IL:IU were found.",
       "                       Effect: M < IU+1-IL",
       "                       Cause:  non-monotonic arithmetic, causing the",
       "                               Sturm sequence to be non-monotonic.",
       "                       Cure:   recalculate, using RANGE='A', and pick",
       "                               out eigenvalues IL:IU.  In some cases,",
       "                               increasing the PARAMETER \"FUDGE\" may",
       "                               make things work.",
       "               = 4:    RANGE='I', and the Gershgorin interval",
       "                       initially used was too small.  No eigenvalues",
       "                       were computed.",
       "                       Probable cause: your machine has sloppy",
       "                                       floating-point arithmetic.",
       "                       Cure: Increase the PARAMETER \"FUDGE\",",
       "                             recompile, and try again."]}},
 "dlasd2"=>
  {"summary"=>
    ["DLASD2 merges the two sets of singular values together into a single",
     "sorted set.  Then it tries to deflate the size of the problem.",
     "There are two ways in which deflation can occur:  when two or more",
     "singular values are close together or if there is a tiny entry in the",
     "Z vector.  For each such occurrence the order of the related secular",
     "equation problem is reduced by one.",
     "DLASD2 is called from DLASD1."],
   "param"=>
    {"NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block.  NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block.  NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has N = NL + NR + 1 rows and",
       "        M = N + SQRE >= N columns."],
     "K"=>
      ["[out]",
       "         K is INTEGER",
       "        Contains the dimension of the non-deflated matrix,",
       "        This is the order of the related secular equation. 1 <= K <=N."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension(N)",
       "        On entry D contains the singular values of the two submatrices",
       "        to be combined.  On exit D contains the trailing (N-K) updated",
       "        singular values (those which were deflated) sorted into",
       "        increasing order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension(N)",
       "        On exit Z contains the updating row vector in the secular",
       "        equation."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "        Contains the diagonal element associated with the added row."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION",
       "        Contains the off-diagonal element associated with the added",
       "        row."],
     "U"=>
      ["[in,out]",
       "         U is DOUBLE PRECISION array, dimension(LDU,N)",
       "        On entry U contains the left singular vectors of two",
       "        submatrices in the two square blocks with corners at (1,1),",
       "        (NL, NL), and (NL+2, NL+2), (N,N).",
       "        On exit U contains the trailing (N-K) updated left singular",
       "        vectors (those which were deflated) in its last N-K columns."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "        The leading dimension of the array U.  LDU >= N."],
     "VT"=>
      ["[in,out]",
       "         VT is DOUBLE PRECISION array, dimension(LDVT,M)",
       "        On entry VT**T contains the right singular vectors of two",
       "        submatrices in the two square blocks with corners at (1,1),",
       "        (NL+1, NL+1), and (NL+2, NL+2), (M,M).",
       "        On exit VT**T contains the trailing (N-K) updated right singular",
       "        vectors (those which were deflated) in its last N-K columns.",
       "        In case SQRE =1, the last row of VT spans the right null",
       "        space."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "        The leading dimension of the array VT.  LDVT >= M."],
     "DSIGMA"=>
      ["[out]",
       "         DSIGMA is DOUBLE PRECISION array, dimension (N)",
       "        Contains a copy of the diagonal elements (K-1 singular values",
       "        and one zero) in the secular equation."],
     "U2"=>
      ["[out]",
       "         U2 is DOUBLE PRECISION array, dimension(LDU2,N)",
       "        Contains a copy of the first K-1 left singular vectors which",
       "        will be used by DLASD3 in a matrix multiply (DGEMM) to solve",
       "        for the new left singular vectors. U2 is arranged into four",
       "        blocks. The first block contains a column with 1 at NL+1 and",
       "        zero everywhere else; the second block contains non-zero",
       "        entries only at and above NL; the third contains non-zero",
       "        entries only below NL+1; and the fourth is dense."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "        The leading dimension of the array U2.  LDU2 >= N."],
     "VT2"=>
      ["[out]",
       "         VT2 is DOUBLE PRECISION array, dimension(LDVT2,N)",
       "        VT2**T contains a copy of the first K right singular vectors",
       "        which will be used by DLASD3 in a matrix multiply (DGEMM) to",
       "        solve for the new right singular vectors. VT2 is arranged into",
       "        three blocks. The first block contains a row that corresponds",
       "        to the special 0 diagonal element in SIGMA; the second block",
       "        contains non-zeros only at and before NL +1; the third block",
       "        contains non-zeros only at and after  NL +2."],
     "LDVT2"=>
      ["[in]",
       "         LDVT2 is INTEGER",
       "        The leading dimension of the array VT2.  LDVT2 >= M."],
     "IDXP"=>
      ["[out]",
       "         IDXP is INTEGER array dimension(N)",
       "        This will contain the permutation used to place deflated",
       "        values of D at the end of the array. On output IDXP(2:K)",
       "        points to the nondeflated D-values and IDXP(K+1:N)",
       "        points to the deflated singular values."],
     "IDX"=>
      ["[out]",
       "         IDX is INTEGER array dimension(N)",
       "        This will contain the permutation used to sort the contents of",
       "        D into ascending order."],
     "IDXC"=>
      ["[out]",
       "         IDXC is INTEGER array dimension(N)",
       "        This will contain the permutation used to arrange the columns",
       "        of the deflated U matrix into three groups:  the first group",
       "        contains non-zero entries only at and above NL, the second",
       "        contains non-zero entries only below NL+2, and the third is",
       "        dense."],
     "IDXQ"=>
      ["[in,out]",
       "         IDXQ is INTEGER array dimension(N)",
       "        This contains the permutation which separately sorts the two",
       "        sub-problems in D into ascending order.  Note that entries in",
       "        the first hlaf of this permutation must first be moved one",
       "        position backward; and entries in the second half",
       "        must first have NL+1 added to their values."],
     "COLTYP"=>
      ["[out]",
       "         COLTYP is INTEGER array dimension(N)",
       "        As workspace, this will contain a label which will indicate",
       "        which of the following types a column in the U2 matrix or a",
       "        row in the VT2 matrix is:",
       "        1 : non-zero in the upper half only",
       "        2 : non-zero in the lower half only",
       "        3 : dense",
       "        4 : deflated",
       "        On exit, it is an array of dimension 4, with COLTYP(I) being",
       "        the dimension of the I-th type columns."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dsbevx"=>
  {"summary"=>
    ["DSBEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric band matrix A.  Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "Q"=>
      ["[out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the N-by-N orthogonal matrix used in the",
       "                        reduction to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'V', then",
       "         LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AB to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "cungbr"=>
  {"summary"=>
    ["CUNGBR generates one of the complex unitary matrices Q or P**H",
     "determined by CGEBRD when reducing a complex matrix A to bidiagonal",
     "form: A = Q * B * P**H.  Q and P**H are defined as products of",
     "elementary reflectors H(i) or G(i) respectively.",
     "If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q",
     "is of order M:",
     "if m >= k, Q = H(1) H(2) . . . H(k) and CUNGBR returns the first n",
     "columns of Q, where m >= n >= k;",
     "if m < k, Q = H(1) H(2) . . . H(m-1) and CUNGBR returns Q as an",
     "M-by-M matrix.",
     "If VECT = 'P', A is assumed to have been a K-by-N matrix, and P**H",
     "is of order N:",
     "if k < n, P**H = G(k) . . . G(2) G(1) and CUNGBR returns the first m",
     "rows of P**H, where n >= m >= k;",
     "if k >= n, P**H = G(n-1) . . . G(2) G(1) and CUNGBR returns P**H as",
     "an N-by-N matrix."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         Specifies whether the matrix Q or the matrix P**H is",
       "         required, as defined in the transformation applied by CGEBRD:",
       "         = 'Q':  generate Q;",
       "         = 'P':  generate P**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q or P**H to be returned.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q or P**H to be returned.",
       "         N >= 0.",
       "         If VECT = 'Q', M >= N >= min(M,K);",
       "         if VECT = 'P', N >= M >= min(N,K)."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         If VECT = 'Q', the number of columns in the original M-by-K",
       "         matrix reduced by CGEBRD.",
       "         If VECT = 'P', the number of rows in the original K-by-N",
       "         matrix reduced by CGEBRD.",
       "         K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by CGEBRD.",
       "         On exit, the M-by-N matrix Q or P**H."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= M."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension",
       "                               (min(M,K)) if VECT = 'Q'",
       "                               (min(N,K)) if VECT = 'P'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i) or G(i), which determines Q or P**H, as",
       "         returned by CGEBRD in its array argument TAUQ or TAUP."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,min(M,N)).",
       "         For optimum performance LWORK >= min(M,N)*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zunmrz"=>
  {"summary"=>
    ["ZUNMRZ overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by ZTZRZF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing",
       "         the meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         ZTZRZF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZTZRZF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chpevx"=>
  {"summary"=>
    ["CHPEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian matrix A in packed storage.",
     "Eigenvalues/vectors can be selected by specifying either a range of",
     "values or a range of indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AP to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the selected eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and",
       "         the index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "cla_hercond_x"=>
  {"summary"=>
    ["   CLA_HERCOND_X computes the infinity norm condition number of",
     "   op(A) * diag(X) where X is a COMPLEX vector."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by CHETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by CHETRF."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension (N)",
       "    The vector X in the formula op(A) * diag(X)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is REAL array, dimension (N).",
       "    Workspace."]}},
 "spbequ"=>
  {"summary"=>
    ["SPBEQU computes row and column scalings intended to equilibrate a",
     "symmetric positive definite band matrix A and reduce its condition",
     "number (with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular of A is stored;",
       "         = 'L':  Lower triangular of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The upper or lower triangle of the symmetric band matrix A,",
       "         stored in the first KD+1 rows of the array.  The j-th column",
       "         of A is stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A.  LDAB >= KD+1."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is REAL",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "slansb"=>
  {"summary"=>
    ["SLANSB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n symmetric band matrix A,  with k super-diagonals.",
     "   SLANSB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANSB as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         band matrix A is supplied.",
       "         = 'U':  Upper triangular part is supplied",
       "         = 'L':  Lower triangular part is supplied"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, SLANSB is",
       "         set to zero."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of super-diagonals or sub-diagonals of the",
       "         band matrix A.  K >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The upper or lower triangle of the symmetric band matrix A,",
       "         stored in the first K+1 rows of AB.  The j-th column of A is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)   = A(i,j) for j<=i<=min(n,j+k)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= K+1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "dlasd5"=>
  {"summary"=>
    ["This subroutine computes the square root of the I-th eigenvalue",
     "of a positive symmetric rank-one modification of a 2-by-2 diagonal",
     "matrix",
     "           diag( D ) * diag( D ) +  RHO * Z * transpose(Z) .",
     "The diagonal entries in the array D are assumed to satisfy",
     "           0 <= D(i) < D(j)  for  i < j .",
     "We also assume RHO > 0 and that the Euclidean norm of the vector",
     "Z is one."],
   "param"=>
    {"I"=>
      ["[in]",
       "         I is INTEGER",
       "        The index of the eigenvalue to be computed.  I = 1 or I = 2."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension ( 2 )",
       "        The original eigenvalues.  We assume 0 <= D(1) < D(2)."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension ( 2 )",
       "        The components of the updating vector."],
     "DELTA"=>
      ["[out]",
       "         DELTA is DOUBLE PRECISION array, dimension ( 2 )",
       "        Contains (D(j) - sigma_I) in its  j-th component.",
       "        The vector DELTA contains the information necessary",
       "        to construct the eigenvectors."],
     "RHO"=>
      ["[in]",
       "         RHO is DOUBLE PRECISION",
       "        The scalar in the symmetric updating formula."],
     "DSIGMA"=>
      ["[out]",
       "         DSIGMA is DOUBLE PRECISION",
       "        The computed sigma_I, the I-th updated eigenvalue."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension ( 2 )",
       "        WORK contains (D(j) + sigma_I) in its  j-th component."]}},
 "sgges"=>
  {"summary"=>
    ["SGGES computes for a pair of N-by-N real nonsymmetric matrices (A,B),",
     "the generalized eigenvalues, the generalized real Schur form (S,T),",
     "optionally, the left and/or right matrices of Schur vectors (VSL and",
     "VSR). This gives the generalized Schur factorization",
     "         (A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T )",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "quasi-triangular matrix S and the upper triangular matrix T.The",
     "leading columns of VSL and VSR then form an orthonormal basis for the",
     "corresponding left and right eigenspaces (deflating subspaces).",
     "(If only the generalized eigenvalues are needed, use the driver",
     "SGGEV instead, which is faster.)",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0 or both being zero.",
     "A pair of matrices (S,T) is in generalized real Schur form if T is",
     "upper triangular with non-negative diagonal and S is block upper",
     "triangular with 1-by-1 and 2-by-2 blocks.  1-by-1 blocks correspond",
     "to real generalized eigenvalues, while 2-by-2 blocks of S will be",
     "\"standardized\" by making the corresponding elements of T have the",
     "form:",
     "        [  a  0  ]",
     "        [  0  b  ]",
     "and the pair of corresponding 2-by-2 blocks in S and T will have a",
     "complex conjugate pair of generalized eigenvalues."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG);"],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is a LOGICAL FUNCTION of three REAL arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         An eigenvalue (ALPHAR(j)+ALPHAI(j))/BETA(j) is selected if",
       "         SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) is true; i.e. if either",
       "         one of a complex conjugate pair of eigenvalues is selected,",
       "         then both complex eigenvalues are selected.",
       "         Note that in the ill-conditioned case, a selected complex",
       "         eigenvalue may no longer satisfy SELCTG(ALPHAR(j),ALPHAI(j),",
       "         BETA(j)) = .TRUE. after ordering. INFO is to be set to N+2",
       "         in this case."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true.  (Complex conjugate pairs for which",
       "         SELCTG is true for either eigenvalue count as 2.)"],
     "ALPHAR"=>["[out]", "         ALPHAR is REAL array, dimension (N)"],
     "ALPHAI"=>["[out]", "         ALPHAI is REAL array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  ALPHAR(j) + ALPHAI(j)*i,",
       "         and  BETA(j),j=1,...,N are the diagonals of the complex Schur",
       "         form (S,T) that would result if the 2-by-2 diagonal blocks of",
       "         the real Schur form of (A,B) were further reduced to",
       "         triangular form using 2-by-2 complex unitary transformations.",
       "         If ALPHAI(j) is zero, then the j-th eigenvalue is real; if",
       "         positive, then the j-th and (j+1)-st eigenvalues are a",
       "         complex conjugate pair, with ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio.",
       "         However, ALPHAR and ALPHAI will be always less than and",
       "         usually comparable with norm(A) in magnitude, and BETA always",
       "         less than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is REAL array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >=1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is REAL array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N = 0, LWORK >= 1, else LWORK >= max(8*N,6*N+16).",
       "         For good performance , LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHAR(j), ALPHAI(j), and BETA(j) should",
       "               be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in SHGEQZ.",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in STGSEN."]}},
 "dpftrf"=>
  {"summary"=>
    ["DPFTRF computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the block version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'T':  The Transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of RFP A is stored;",
       "         = 'L':  Lower triangle of RFP A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension ( N*(N+1)/2 );",
       "         On entry, the symmetric matrix A in RFP format. RFP format is",
       "         described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'",
       "         then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'T' then RFP is",
       "         the transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the NT elements of",
       "         upper packed A. If UPLO = 'L' the RFP A contains the elements",
       "         of lower packed A. The LDA of RFP A is (N+1)/2 when TRANSR =",
       "         'T'. When TRANSR is 'N' the LDA is N+1 when N is even and N",
       "         is odd. See the Note below for more details.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization RFP A = U**T*U or RFP A = L*L**T."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "dppsv"=>
  {"summary"=>
    ["DPPSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite matrix stored in",
     "packed format and X and B are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**T* U,  if UPLO = 'U', or",
     "   A = L * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is a lower triangular",
     "matrix.  The factored form of A is then used to solve the system of",
     "equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T, in the same storage",
       "         format as A."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "chbev_2stage"=>
  {"summary"=>
    ["CHBEV_2STAGE computes all the eigenvalues and, optionally, eigenvectors of",
     "a complex Hermitian band matrix A using the 2stage technique for",
     "the reduction to tridiagonal."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension LWORK",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is REAL array, dimension (max(1,3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "zhseqr"=>
  {"summary"=>
    ["   ZHSEQR computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**H, where T is an upper triangular matrix (the",
     "   Schur form), and Z is the unitary matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input unitary",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the unitary matrix Q:  A = Q*H*Q**H = (QZ)*T*(QZ)**H."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "          = 'E':  compute eigenvalues only;",
       "          = 'S':  compute eigenvalues and the Schur form T."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "          = 'N':  no Schur vectors are computed;",
       "          = 'I':  Z is initialized to the unit matrix and the matrix Z",
       "                  of Schur vectors of H is returned;",
       "          = 'V':  Z must contain an unitary matrix Q on entry, and",
       "                  the product Q*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "          set by a previous call to ZGEBAL, and then passed to ZGEHRD",
       "          when the matrix output by ZGEBAL is reduced to Hessenberg",
       "          form. Otherwise ILO and IHI should be set to 1 and N",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX*16 array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and JOB = 'S', H contains the upper",
       "          triangular matrix T from the Schur decomposition (the",
       "          Schur form). If INFO = 0 and JOB = 'E', the contents of",
       "          H are unspecified on exit.  (The output value of H when",
       "          INFO.GT.0 is given under the description of INFO below.)",
       "          Unlike earlier versions of ZHSEQR, this subroutine may",
       "          explicitly H(i,j) = 0 for i.GT.j and j = 1, 2, ... ILO-1",
       "          or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX*16 array, dimension (N)",
       "          The computed eigenvalues. If JOB = 'S', the eigenvalues are",
       "          stored in the same order as on the diagonal of the Schur",
       "          form returned in H, with W(i) = H(i,i)."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ,N)",
       "          If COMPZ = 'N', Z is not referenced.",
       "          If COMPZ = 'I', on entry Z need not be set and on exit,",
       "          if INFO = 0, Z contains the unitary matrix Z of the Schur",
       "          vectors of H.  If COMPZ = 'V', on entry Z must contain an",
       "          N-by-N matrix Q, which is assumed to be equal to the unit",
       "          matrix except for the submatrix Z(ILO:IHI,ILO:IHI). On exit,",
       "          if INFO = 0, Z contains Q*Z.",
       "          Normally Q is the unitary matrix generated by ZUNGHR",
       "          after the call to ZGEHRD which formed the Hessenberg matrix",
       "          H. (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if COMPZ = 'I' or",
       "          COMPZ = 'V', then LDZ.GE.MAX(1,N).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (LWORK)",
       "          On exit, if INFO = 0, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient and delivers very good and sometimes",
       "          optimal performance.  However, LWORK as large as 11*N",
       "          may be required for optimal performance.  A workspace",
       "          query is recommended to determine the optimal workspace",
       "          size.",
       "          If LWORK = -1, then ZHSEQR does a workspace query.",
       "          In this case, ZHSEQR checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .LT. 0:  if INFO = -i, the i-th argument had an illegal",
       "                   value",
       "          .GT. 0:  if INFO = i, ZHSEQR failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and JOB = 'E', then on exit, the",
       "               remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and JOB   = 'S', then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is a unitary matrix.  The final",
       "               value of  H is upper Hessenberg and triangular in",
       "               rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and COMPZ = 'V', then on exit",
       "                 (final value of Z)  =  (initial value of Z)*U",
       "               where U is the unitary matrix in (*) (regard-",
       "               less of the value of JOB.)",
       "               If INFO .GT. 0 and COMPZ = 'I', then on exit",
       "                     (final value of Z)  = U",
       "               where U is the unitary matrix in (*) (regard-",
       "               less of the value of JOB.)",
       "               If INFO .GT. 0 and COMPZ = 'N', then Z is not",
       "               accessed."]}},
 "zcposv"=>
  {"summary"=>
    ["ZCPOSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite matrix and X and B",
     "are N-by-NRHS matrices.",
     "ZCPOSV first attempts to factorize the matrix in COMPLEX and use this",
     "factorization within an iterative refinement procedure to produce a",
     "solution with COMPLEX*16 normwise backward error quality (see below).",
     "If the approach fails the method switches to a COMPLEX*16",
     "factorization and solve.",
     "The iterative refinement is not going to be a winning strategy if",
     "the ratio COMPLEX performance over COMPLEX*16 performance is too",
     "small. A reasonable strategy should take the number of right-hand",
     "sides and the size of the matrix into account. This might be done",
     "with a call to ILAENV in the future. Up to now, we always try",
     "iterative refinement.",
     "The iterative refinement process is stopped if",
     "    ITER > ITERMAX",
     "or for all the RHS we have:",
     "    RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX",
     "where",
     "    o ITER is the number of the current iteration in the iterative",
     "      refinement process",
     "    o RNRM is the infinity-norm of the residual",
     "    o XNRM is the infinity-norm of the solution",
     "    o ANRM is the infinity-operator-norm of the matrix A",
     "    o EPS is the machine epsilon returned by DLAMCH('Epsilon')",
     "The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00",
     "respectively."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array,",
       "         dimension (LDA,N)",
       "         On entry, the Hermitian matrix A. If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         Note that the imaginary parts of the diagonal",
       "         elements need not be set and are assumed to be zero.",
       "         On exit, if iterative refinement has been successfully used",
       "         (INFO.EQ.0 and ITER.GE.0, see description below), then A is",
       "         unchanged, if double precision factorization has been used",
       "         (INFO.EQ.0 and ITER.LT.0, see description below), then the",
       "         array A contains the factor U or L from the Cholesky",
       "         factorization A = U**H*U or A = L*L**H."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The N-by-NRHS right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         If INFO = 0, the N-by-NRHS solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (N*NRHS)",
       "         This array is used to hold the residual vectors."],
     "SWORK"=>
      ["[out]",
       "         SWORK is COMPLEX array, dimension (N*(N+NRHS))",
       "         This array is used to use the single precision matrix and the",
       "         right-hand sides or solutions in single precision."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "ITER"=>
      ["[out]",
       "         ITER is INTEGER",
       "         < 0: iterative refinement has failed, COMPLEX*16",
       "              factorization has been performed",
       "              -1 : the routine fell back to full precision for",
       "                   implementation- or machine-specific reasons",
       "              -2 : narrowing the precision induced an overflow,",
       "                   the routine fell back to full precision",
       "              -3 : failure of CPOTRF",
       "              -31: stop the iterative refinement after the 30th",
       "                   iterations",
       "         > 0: iterative refinement has been successfully used.",
       "              Returns the number of iterations"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of",
       "               (COMPLEX*16) A is not positive definite, so the",
       "               factorization could not be completed, and the solution",
       "               has not been computed."]}},
 "cunghr"=>
  {"summary"=>
    ["CUNGHR generates a complex unitary matrix Q which is defined as the",
     "product of IHI-ILO elementary reflectors of order N, as returned by",
     "CGEHRD:",
     "Q = H(ilo) H(ilo+1) . . . H(ihi-1)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI must have the same values as in the previous call",
       "         of CGEHRD. Q is equal to the unit matrix except in the",
       "         submatrix Q(ilo+1:ihi,ilo+1:ihi).",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by CGEHRD.",
       "         On exit, the N-by-N unitary matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGEHRD."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= IHI-ILO.",
       "         For optimum performance LWORK >= (IHI-ILO)*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sppsv"=>
  {"summary"=>
    ["SPPSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite matrix stored in",
     "packed format and X and B are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**T* U,  if UPLO = 'U', or",
     "   A = L * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is a lower triangular",
     "matrix.  The factored form of A is then used to solve the system of",
     "equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T, in the same storage",
       "         format as A."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "sgetc2"=>
  {"summary"=>
    ["SGETC2 computes an LU factorization with complete pivoting of the",
     "n-by-n matrix A. The factorization has the form A = P * L * U * Q,",
     "where P and Q are permutation matrices, L is lower triangular with",
     "unit diagonal elements and U is upper triangular.",
     "This is the Level 2 BLAS algorithm."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the n-by-n matrix A to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U*Q; the unit diagonal elements of L are not stored.",
       "         If U(k, k) appears to be less than SMIN, U(k, k) is given the",
       "         value of SMIN, i.e., giving a nonsingular perturbed system."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension(N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[out]",
       "         JPIV is INTEGER array, dimension(N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0: successful exit",
       "          > 0: if INFO = k, U(k, k) is likely to produce owerflow if",
       "               we try to solve for x in Ax = b. So U is perturbed to",
       "               avoid the overflow."]}},
 "ctrttp"=>
  {"summary"=>
    ["CTRTTP copies a triangular matrix A from full format (TR) to standard",
     "packed format (TP)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices AP and A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AP"=>
      ["[out]",
       "         AP is COMPLEX array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ztftri"=>
  {"summary"=>
    ["ZTFTRI computes the inverse of a triangular matrix A stored in RFP",
     "format.",
     "This is a Level 3 BLAS version of the algorithm."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension ( N*(N+1)/2 );",
       "         On entry, the triangular matrix A in RFP format. RFP format",
       "         is described by TRANSR, UPLO, and N as follows: If TRANSR =",
       "         'N' then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'C' then RFP is",
       "         the Conjugate-transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the nt elements of",
       "         upper packed A; If UPLO = 'L' the RFP A contains the nt",
       "         elements of lower packed A. The LDA of RFP A is (N+1)/2 when",
       "         TRANSR = 'C'. When TRANSR is 'N' the LDA is N+1 when N is",
       "         even and N is odd. See the Note below for more details.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, A(i,i) is exactly zero.  The triangular",
       "              matrix is singular and its inverse can not be computed."]}},
 "cporfs"=>
  {"summary"=>
    ["CPORFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian positive definite,",
     "and provides error bounds and backward error estimates for the",
     "solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The Hermitian matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H, as computed by CPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by CPOTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlar1v"=>
  {"summary"=>
    ["DLAR1V computes the (scaled) r-th column of the inverse of",
     "the sumbmatrix in rows B1 through BN of the tridiagonal matrix",
     "L D L**T - sigma I. When sigma is close to an eigenvalue, the",
     "computed vector is an accurate eigenvector. Usually, r corresponds",
     "to the index where the eigenvector is largest in magnitude.",
     "The following steps accomplish this computation :",
     "(a) Stationary qd transform,  L D L**T - sigma I = L(+) D(+) L(+)**T,",
     "(b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,",
     "(c) Computation of the diagonal elements of the inverse of",
     "    L D L**T - sigma I by combining the above transforms, and choosing",
     "    r as the index where the diagonal of the inverse is (one of the)",
     "    largest in magnitude.",
     "(d) Computation of the (scaled) r-th column of the inverse using the",
     "    twisted factorization obtained by combining the top part of the",
     "    the stationary and the bottom part of the progressive transform."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix L D L**T."],
     "B1"=>
      ["[in]",
       "         B1 is INTEGER",
       "          First index of the submatrix of L D L**T."],
     "BN"=>
      ["[in]",
       "         BN is INTEGER",
       "          Last index of the submatrix of L D L**T."],
     "LAMBDA"=>
      ["[in]",
       "         LAMBDA is DOUBLE PRECISION",
       "          The shift. In order to compute an accurate eigenvector,",
       "          LAMBDA should be a good approximation to an eigenvalue",
       "          of L D L**T."],
     "L"=>
      ["[in]",
       "         L is DOUBLE PRECISION array, dimension (N-1)",
       "          The (n-1) subdiagonal elements of the unit bidiagonal matrix",
       "          L, in elements 1 to N-1."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "          The n diagonal elements of the diagonal matrix D."],
     "LD"=>
      ["[in]",
       "         LD is DOUBLE PRECISION array, dimension (N-1)",
       "          The n-1 elements L(i)*D(i)."],
     "LLD"=>
      ["[in]",
       "         LLD is DOUBLE PRECISION array, dimension (N-1)",
       "          The n-1 elements L(i)*L(i)*D(i)."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "          The minimum pivot in the Sturm sequence."],
     "GAPTOL"=>
      ["[in]",
       "         GAPTOL is DOUBLE PRECISION",
       "          Tolerance that indicates when eigenvector entries are negligible",
       "          w.r.t. their contribution to the residual."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (N)",
       "          On input, all entries of Z must be set to 0.",
       "          On output, Z contains the (scaled) r-th column of the",
       "          inverse. The scaling is such that Z(R) equals 1."],
     "WANTNC"=>
      ["[in]",
       "         WANTNC is LOGICAL",
       "          Specifies whether NEGCNT has to be computed."],
     "NEGCNT"=>
      ["[out]",
       "         NEGCNT is INTEGER",
       "          If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin",
       "          in the  matrix factorization L D L**T, and NEGCNT = -1 otherwise."],
     "ZTZ"=>
      ["[out]",
       "         ZTZ is DOUBLE PRECISION",
       "          The square of the 2-norm of Z."],
     "MINGMA"=>
      ["[out]",
       "         MINGMA is DOUBLE PRECISION",
       "          The reciprocal of the largest (in magnitude) diagonal",
       "          element of the inverse of L D L**T - sigma I."],
     "R"=>
      ["[in,out]",
       "         R is INTEGER",
       "          The twist index for the twisted factorization used to",
       "          compute Z.",
       "          On input, 0 <= R <= N. If R is input as 0, R is set to",
       "          the index where (L D L**T - sigma I)^{-1} is largest",
       "          in magnitude. If 1 <= R <= N, R is unchanged.",
       "          On output, R contains the twist index used to compute Z.",
       "          Ideally, R designates the position of the maximum entry in the",
       "          eigenvector."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension (2)",
       "          The support of the vector in Z, i.e., the vector Z is",
       "          nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 )."],
     "NRMINV"=>
      ["[out]",
       "         NRMINV is DOUBLE PRECISION",
       "          NRMINV = 1/SQRT( ZTZ )"],
     "RESID"=>
      ["[out]",
       "         RESID is DOUBLE PRECISION",
       "          The residual of the FP vector.",
       "          RESID = ABS( MINGMA )/SQRT( ZTZ )"],
     "RQCORR"=>
      ["[out]",
       "         RQCORR is DOUBLE PRECISION",
       "          The Rayleigh Quotient correction to LAMBDA.",
       "          RQCORR = MINGMA*TMP"],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"]}},
 "dlaic1"=>
  {"summary"=>
    ["DLAIC1 applies one step of incremental condition estimation in",
     "its simplest version:",
     "Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j",
     "lower triangular matrix L, such that",
     "         twonorm(L*x) = sest",
     "Then DLAIC1 computes sestpr, s, c such that",
     "the vector",
     "                [ s*x ]",
     "         xhat = [  c  ]",
     "is an approximate singular vector of",
     "                [ L       0  ]",
     "         Lhat = [ w**T gamma ]",
     "in the sense that",
     "         twonorm(Lhat*xhat) = sestpr.",
     "Depending on JOB, an estimate for the largest or smallest singular",
     "value is computed.",
     "Note that [s c]**T and sestpr**2 is an eigenpair of the system",
     "    diag(sest*sest, 0) + [alpha  gamma] * [ alpha ]",
     "                                          [ gamma ]",
     "where  alpha =  x**T*w."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is INTEGER",
       "         = 1: an estimate for the largest singular value is computed.",
       "         = 2: an estimate for the smallest singular value is computed."],
     "J"=>["[in]", "         J is INTEGER", "         Length of X and W"],
     "X"=>
      ["[in]",
       "         X is DOUBLE PRECISION array, dimension (J)",
       "         The j-vector x."],
     "SEST"=>
      ["[in]",
       "         SEST is DOUBLE PRECISION",
       "         Estimated singular value of j by j matrix L"],
     "W"=>
      ["[in]",
       "         W is DOUBLE PRECISION array, dimension (J)",
       "         The j-vector w."],
     "GAMMA"=>
      ["[in]",
       "         GAMMA is DOUBLE PRECISION",
       "         The diagonal element gamma."],
     "SESTPR"=>
      ["[out]",
       "         SESTPR is DOUBLE PRECISION",
       "         Estimated singular value of (j+1) by (j+1) matrix Lhat."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION",
       "         Sine needed in forming xhat."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION",
       "         Cosine needed in forming xhat."]}},
 "cungr2"=>
  {"summary"=>
    ["CUNGR2 generates an m by n complex matrix Q with orthonormal rows,",
     "which is defined as the last m rows of a product of k elementary",
     "reflectors of order n",
     "      Q  =  H(1)**H H(2)**H . . . H(k)**H",
     "as returned by CGERQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the (m-k+i)-th row must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by CGERQF in the last k rows of its array argument",
       "         A.",
       "         On exit, the m-by-n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGERQF."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "stgsja"=>
  {"summary"=>
    ["STGSJA computes the generalized singular value decomposition (GSVD)",
     "of two real upper triangular (or trapezoidal) matrices A and B.",
     "On entry, it is assumed that matrices A and B have the following",
     "forms, which may be obtained by the preprocessing subroutine SGGSVP",
     "from a general M-by-N matrix A and P-by-N matrix B:",
     "             N-K-L  K    L",
     "   A =    K ( 0    A12  A13 ) if M-K-L >= 0;",
     "          L ( 0     0   A23 )",
     "      M-K-L ( 0     0    0  )",
     "           N-K-L  K    L",
     "   A =  K ( 0    A12  A13 ) if M-K-L < 0;",
     "      M-K ( 0     0   A23 )",
     "           N-K-L  K    L",
     "   B =  L ( 0     0   B13 )",
     "      P-L ( 0     0    0  )",
     "where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular",
     "upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,",
     "otherwise A23 is (M-K)-by-L upper trapezoidal.",
     "On exit,",
     "       U**T *A*Q = D1*( 0 R ),    V**T *B*Q = D2*( 0 R ),",
     "where U, V and Q are orthogonal matrices.",
     "R is a nonsingular upper triangular matrix, and D1 and D2 are",
     "``diagonal'' matrices, which are of the following structures:",
     "If M-K-L >= 0,",
     "                    K  L",
     "       D1 =     K ( I  0 )",
     "                L ( 0  C )",
     "            M-K-L ( 0  0 )",
     "                  K  L",
     "       D2 = L   ( 0  S )",
     "            P-L ( 0  0 )",
     "               N-K-L  K    L",
     "  ( 0 R ) = K (  0   R11  R12 ) K",
     "            L (  0    0   R22 ) L",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(K+L) ),",
     "  S = diag( BETA(K+1),  ... , BETA(K+L) ),",
     "  C**2 + S**2 = I.",
     "  R is stored in A(1:K+L,N-K-L+1:N) on exit.",
     "If M-K-L < 0,",
     "               K M-K K+L-M",
     "    D1 =   K ( I  0    0   )",
     "         M-K ( 0  C    0   )",
     "                 K M-K K+L-M",
     "    D2 =   M-K ( 0  S    0   )",
     "         K+L-M ( 0  0    I   )",
     "           P-L ( 0  0    0   )",
     "               N-K-L  K   M-K  K+L-M",
     "( 0 R ) =    K ( 0    R11  R12  R13  )",
     "          M-K ( 0     0   R22  R23  )",
     "        K+L-M ( 0     0    0   R33  )",
     "where",
     "C = diag( ALPHA(K+1), ... , ALPHA(M) ),",
     "S = diag( BETA(K+1),  ... , BETA(M) ),",
     "C**2 + S**2 = I.",
     "R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored",
     "    (  0  R22 R23 )",
     "in B(M-K+1:L,N+M-K-L+1:N) on exit.",
     "The computation of the orthogonal transformation matrices U, V or Q",
     "is optional.  These matrices may either be formed explicitly, or they",
     "may be postmultiplied into input matrices U1, V1, or Q1."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  U must contain an orthogonal matrix U1 on entry, and",
       "                 the product U1*U is returned;",
       "         = 'I':  U is initialized to the unit matrix, and the",
       "                 orthogonal matrix U is returned;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  V must contain an orthogonal matrix V1 on entry, and",
       "                 the product V1*V is returned;",
       "         = 'I':  V is initialized to the unit matrix, and the",
       "                 orthogonal matrix V is returned;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Q must contain an orthogonal matrix Q1 on entry, and",
       "                 the product Q1*Q is returned;",
       "         = 'I':  Q is initialized to the unit matrix, and the",
       "                 orthogonal matrix Q is returned;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "K"=>["[in]", "         K is INTEGER"],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         K and L specify the subblocks in the input matrices A and B:",
       "         A23 = A(K+1:MIN(K+L,M),N-L+1:N) and B13 = B(1:L,N-L+1:N)",
       "         of A and B, whose GSVD is going to be computed by STGSJA.",
       "         See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A(N-K+1:N,1:MIN(K+L,M) ) contains the triangular",
       "         matrix R or part of R.  See Purpose for details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, if necessary, B(M-K+1:L,N+M-K-L+1:N) contains",
       "         a part of R.  See Purpose for details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TOLA"=>["[in]", "         TOLA is REAL"],
     "TOLB"=>
      ["[in]",
       "         TOLB is REAL",
       "         TOLA and TOLB are the convergence criteria for the Jacobi-",
       "         Kogbetliantz iteration procedure. Generally, they are the",
       "         same as used in the preprocessing step, say",
       "             TOLA = max(M,N)*norm(A)*MACHEPS,",
       "             TOLB = max(P,N)*norm(B)*MACHEPS."],
     "ALPHA"=>["[out]", "         ALPHA is REAL array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         On exit, ALPHA and BETA contain the generalized singular",
       "         value pairs of A and B;",
       "           ALPHA(1:K) = 1,",
       "           BETA(1:K)  = 0,",
       "         and if M-K-L >= 0,",
       "           ALPHA(K+1:K+L) = diag(C),",
       "           BETA(K+1:K+L)  = diag(S),",
       "         or if M-K-L < 0,",
       "           ALPHA(K+1:M)= C, ALPHA(M+1:K+L)= 0",
       "           BETA(K+1:M) = S, BETA(M+1:K+L) = 1.",
       "         Furthermore, if K+L < N,",
       "           ALPHA(K+L+1:N) = 0 and",
       "           BETA(K+L+1:N)  = 0."],
     "U"=>
      ["[in,out]",
       "         U is REAL array, dimension (LDU,M)",
       "         On entry, if JOBU = 'U', U must contain a matrix U1 (usually",
       "         the orthogonal matrix returned by SGGSVP).",
       "         On exit,",
       "         if JOBU = 'I', U contains the orthogonal matrix U;",
       "         if JOBU = 'U', U contains the product U1*U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[in,out]",
       "         V is REAL array, dimension (LDV,P)",
       "         On entry, if JOBV = 'V', V must contain a matrix V1 (usually",
       "         the orthogonal matrix returned by SGGSVP).",
       "         On exit,",
       "         if JOBV = 'I', V contains the orthogonal matrix V;",
       "         if JOBV = 'V', V contains the product V1*V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "         On entry, if JOBQ = 'Q', Q must contain a matrix Q1 (usually",
       "         the orthogonal matrix returned by SGGSVP).",
       "         On exit,",
       "         if JOBQ = 'I', Q contains the orthogonal matrix Q;",
       "         if JOBQ = 'Q', Q contains the product Q1*Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (2*N)"],
     "NCYCLE"=>
      ["[out]",
       "         NCYCLE is INTEGER",
       "         The number of cycles required for convergence."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the procedure does not converge after MAXIT cycles.",
       " Internal Parameters",
       " ===================",
       " MAXIT   INTEGER",
       "         MAXIT specifies the total loops that the iterative procedure",
       "         may take. If after MAXIT cycles, the routine fails to",
       "         converge, we return INFO = 1."]}},
 "dla_gerfsx_extended"=>
  {"summary"=>
    ["DLA_GERFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by DGERFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERRS_N",
     "and ERRS_C for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERRS_N and ERRS_C."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "TRANS_TYPE"=>
      ["[in]",
       "         TRANS_TYPE is INTEGER",
       "    Specifies the transposition operation on A.",
       "    The value is defined by ILATRANS(T) where T is a CHARACTER and",
       "    T    = 'N':  No transpose",
       "         = 'T':  Transpose",
       "         = 'C':  Conjugate transpose"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by DGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by DGETRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension",
       "                   (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by DGETRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by DLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERRS_N",
       "    and ERRS_C).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERRS_N"=>
      ["[in,out]",
       "         ERRS_N is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERRS_N(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERRS_N(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERRS_C"=>
      ["[in,out]",
       "         ERRS_C is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERRS_C is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERRS_C(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERRS_C(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is DOUBLE PRECISION array, dimension (N)",
       "    Workspace. This can be the same workspace passed for Y_TAIL."],
     "DY"=>
      ["[in]",
       "         DY is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERRS_N and ERRS_C may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is DOUBLE PRECISION",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is DOUBLE PRECISION",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to DGETRS had an illegal",
       "            value"]}},
 "dgels"=>
  {"summary"=>
    ["DGELS solves overdetermined or underdetermined real linear systems",
     "involving an M-by-N matrix A, or its transpose, using a QR or LQ",
     "factorization of A.  It is assumed that A has full rank.",
     "The following options are provided:",
     "1. If TRANS = 'N' and m >= n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A*X ||.",
     "2. If TRANS = 'N' and m < n:  find the minimum norm solution of",
     "   an underdetermined system A * X = B.",
     "3. If TRANS = 'T' and m >= n:  find the minimum norm solution of",
     "   an underdetermined system A**T * X = B.",
     "4. If TRANS = 'T' and m < n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A**T * X ||.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': the linear system involves A;",
       "         = 'T': the linear system involves A**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of the matrices B and X. NRHS >=0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "           if M >= N, A is overwritten by details of its QR",
       "                      factorization as returned by DGEQRF;",
       "           if M <  N, A is overwritten by details of its LQ",
       "                      factorization as returned by DGELQF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the matrix B of right hand side vectors, stored",
       "         columnwise; B is M-by-NRHS if TRANS = 'N', or N-by-NRHS",
       "         if TRANS = 'T'.",
       "         On exit, if INFO = 0, B is overwritten by the solution",
       "         vectors, stored columnwise:",
       "         if TRANS = 'N' and m >= n, rows 1 to n of B contain the least",
       "         squares solution vectors; the residual sum of squares for the",
       "         solution in each column is given by the sum of squares of",
       "         elements N+1 to M in that column;",
       "         if TRANS = 'N' and m < n, rows 1 to N of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'T' and m >= n, rows 1 to M of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'T' and m < n, rows 1 to M of B contain the",
       "         least squares solution vectors; the residual sum of squares",
       "         for the solution in each column is given by the sum of",
       "         squares of elements M+1 to N in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= MAX(1,M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= max( 1, MN + max( MN, NRHS ) ).",
       "         For optimal performance,",
       "         LWORK >= max( 1, MN + max( MN, NRHS )*NB ).",
       "         where MN = min(M,N) and NB is the optimum block size.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO =  i, the i-th diagonal element of the",
       "               triangular factor of A is zero, so that A does not have",
       "               full rank; the least squares solution could not be",
       "               computed."]}},
 "zunmr2"=>
  {"summary"=>
    ["ZUNMR2 overwrites the general complex m-by-n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**H* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**H if SIDE = 'R' and TRANS = 'C',",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1)**H H(2)**H . . . H(k)**H",
     "as returned by ZGERQF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left",
       "         = 'R': apply Q or Q**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         ZGERQF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGERQF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zla_gbrcond_x"=>
  {"summary"=>
    ["   ZLA_GBRCOND_X Computes the infinity norm condition number of",
     "   op(A) * diag(X) where X is a COMPLEX*16 vector."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "    On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX*16 array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by ZGBTRF.  U is stored as an upper triangular",
       "    band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1,",
       "    and the multipliers used during the factorization are stored",
       "    in rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by ZGBTRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension (N)",
       "    The vector X in the formula op(A) * diag(X)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX*16 array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is DOUBLE PRECISION array, dimension (N).",
       "    Workspace."]}},
 "sla_gerfsx_extended"=>
  {"summary"=>
    ["SLA_GERFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by SGERFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERRS_N",
     "and ERRS_C for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERRS_N and ERRS_C."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "TRANS_TYPE"=>
      ["[in]",
       "         TRANS_TYPE is INTEGER",
       "    Specifies the transposition operation on A.",
       "    The value is defined by ILATRANS(T) where T is a CHARACTER and",
       "    T    = 'N':  No transpose",
       "         = 'T':  Transpose",
       "         = 'C':  Conjugate transpose"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by SGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by SGETRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by SGETRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is REAL array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by SLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERRS_N",
       "    and ERRS_C).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERRS_N"=>
      ["[in,out]",
       "         ERRS_N is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERRS_N(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERRS_N(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERRS_C"=>
      ["[in,out]",
       "         ERRS_C is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERRS_C is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERRS_C(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERRS_C(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is REAL array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is REAL array, dimension (N)",
       "    Workspace. This can be the same workspace passed for Y_TAIL."],
     "DY"=>
      ["[in]",
       "         DY is REAL array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is REAL array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERRS_N and ERRS_C may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is REAL",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is REAL",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to SGETRS had an illegal",
       "            value"]}},
 "chetrs_3"=>
  {"summary"=>
    ["CHETRS_3 solves a system of linear equations A * X = B with a complex",
     "Hermitian matrix A using the factorization computed",
     "by CHETRF_RK or CHETRF_BK:",
     "   A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This algorithm is using Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**H)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**H)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by CHETRF_RK and CHETRF_BK:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF_RK or CHETRF_BK."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dggglm"=>
  {"summary"=>
    ["DGGGLM solves a general Gauss-Markov linear model (GLM) problem:",
     "        minimize || y ||_2   subject to   d = A*x + B*y",
     "            x",
     "where A is an N-by-M matrix, B is an N-by-P matrix, and d is a",
     "given N-vector. It is assumed that M <= N <= M+P, and",
     "           rank(A) = M    and    rank( A B ) = N.",
     "Under these assumptions, the constrained equation is always",
     "consistent, and there is a unique solution x and a minimal 2-norm",
     "solution y, which is obtained using a generalized QR factorization",
     "of the matrices (A, B) given by",
     "   A = Q*(R),   B = Q*T*Z.",
     "         (0)",
     "In particular, if matrix B is square nonsingular, then the problem",
     "GLM is equivalent to the following weighted linear least squares",
     "problem",
     "             minimize || inv(B)*(d-A*x) ||_2",
     "                 x",
     "where inv(B) denotes the inverse of B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrices A and B.  N >= 0."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix A.  0 <= M <= N."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of columns of the matrix B.  P >= N-M."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,M)",
       "         On entry, the N-by-M matrix A.",
       "         On exit, the upper triangular part of the array A contains",
       "         the M-by-M upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,P)",
       "         On entry, the N-by-P matrix B.",
       "         On exit, if N <= P, the upper triangle of the subarray",
       "         B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T;",
       "         if N > P, the elements on and above the (N-P)th subdiagonal",
       "         contain the N-by-P upper trapezoidal matrix T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, D is the left hand side of the GLM equation.",
       "         On exit, D is destroyed."],
     "X"=>["[out]", "         X is DOUBLE PRECISION array, dimension (M)"],
     "Y"=>
      ["[out]",
       "         Y is DOUBLE PRECISION array, dimension (P)",
       "         On exit, X and Y are the solutions of the GLM problem."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N+M+P).",
       "         For optimum performance, LWORK >= M+min(N,P)+max(N,P)*NB,",
       "         where NB is an upper bound for the optimal blocksizes for",
       "         DGEQRF, SGERQF, DORMQR and SORMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the upper triangular factor R associated with A in the",
       "               generalized QR factorization of the pair (A, B) is",
       "               singular, so that rank(A) < M; the least squares",
       "               solution could not be computed.",
       "         = 2:  the bottom (N-M) by (N-M) part of the upper trapezoidal",
       "               factor T associated with B in the generalized QR",
       "               factorization of the pair (A, B) is singular, so that",
       "               rank( A B ) < N; the least squares solution could not",
       "               be computed."]}},
 "ilaslr"=>
  {"summary"=>["ILASLR scans A for its last non-zero row."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."]}},
 "slaed4"=>
  {"summary"=>
    ["This subroutine computes the I-th updated eigenvalue of a symmetric",
     "rank-one modification to a diagonal matrix whose elements are",
     "given in the array d, and that",
     "           D(i) < D(j)  for  i < j",
     "and that RHO > 0.  This is arranged by the calling routine, and is",
     "no loss in generality.  The rank-one modified system is thus",
     "           diag( D )  +  RHO * Z * Z_transpose.",
     "where we assume the Euclidean norm of Z is 1.",
     "The method consists of approximating the rational functions in the",
     "secular equation by simpler interpolating rational functions."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "        The length of all arrays."],
     "I"=>
      ["[in]",
       "         I is INTEGER",
       "        The index of the eigenvalue to be computed.  1 <= I <= N."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "        The original eigenvalues.  It is assumed that they are in",
       "        order, D(I) < D(J)  for I < J."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension (N)",
       "        The components of the updating vector."],
     "DELTA"=>
      ["[out]",
       "         DELTA is REAL array, dimension (N)",
       "        If N .GT. 2, DELTA contains (D(j) - lambda_I) in its  j-th",
       "        component.  If N = 1, then DELTA(1) = 1. If N = 2, see SLAED5",
       "        for detail. The vector DELTA contains the information necessary",
       "        to construct the eigenvectors by SLAED3 and SLAED9."],
     "RHO"=>
      ["[in]",
       "         RHO is REAL",
       "        The scalar in the symmetric updating formula."],
     "DLAM"=>
      ["[out]",
       "         DLAM is REAL",
       "        The computed lambda_I, the I-th updated eigenvalue."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit",
       "        > 0:  if INFO = 1, the updating process failed."]}},
 "zunmql"=>
  {"summary"=>
    ["ZUNMQL overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by ZGEQLF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         ZGEQLF in the last k columns of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGEQLF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should genreally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgbtrs"=>
  {"summary"=>
    ["DGBTRS solves a system of linear equations",
     "   A * X = B  or  A**T * X = B",
     "with a general band matrix A using the LU factorization computed",
     "by DGBTRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations.",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T* X = B  (Transpose)",
       "         = 'C':  A**T* X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by DGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= N, row i of the matrix was",
       "         interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "sorgrq"=>
  {"summary"=>
    ["SORGRQ generates an M-by-N real matrix Q with orthonormal rows,",
     "which is defined as the last M rows of a product of K elementary",
     "reflectors of order N",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by SGERQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the (m-k+i)-th row must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by SGERQF in the last k rows of its array argument",
       "         A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGERQF."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "zgbsv"=>
  {"summary"=>
    ["ZGBSV computes the solution to a complex system of linear equations",
     "A * X = B, where A is a band matrix of order N with KL subdiagonals",
     "and KU superdiagonals, and X and B are N-by-NRHS matrices.",
     "The LU decomposition with partial pivoting and row interchanges is",
     "used to factor A as A = L * U, where L is a product of permutation",
     "and unit lower triangular matrices with KL subdiagonals, and U is",
     "upper triangular with KL+KU superdiagonals.  The factored form of A",
     "is then used to solve the system of equations A * X = B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(KL+KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+KL)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices that define the permutation matrix P;",
       "         row i of the matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero.  The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and the solution has not been computed."]}},
 "slangb"=>
  {"summary"=>
    ["SLANGB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n band matrix  A,  with kl sub-diagonals and ku super-diagonals.",
     "   SLANGB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANGB as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, SLANGB is",
       "         set to zero."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of sub-diagonals of the matrix A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of super-diagonals of the matrix A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The band matrix A, stored in rows 1 to KL+KU+1.  The j-th",
       "         column of A is stored in the j-th column of the array AB as",
       "         follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "dlartg"=>
  {"summary"=>
    ["DLARTG generate a plane rotation so that",
     "   [  CS  SN  ]  .  [ F ]  =  [ R ]   where CS**2 + SN**2 = 1.",
     "   [ -SN  CS  ]     [ G ]     [ 0 ]",
     "This is a slower, more accurate version of the BLAS1 routine DROTG,",
     "with the following other differences:",
     "   F and G are unchanged on return.",
     "   If G=0, then CS=1 and SN=0.",
     "   If F=0 and (G .ne. 0), then CS=0 and SN=1 without doing any",
     "      floating point operations (saves work in DBDSQR when",
     "      there are zeros on the diagonal).",
     "If F exceeds G in magnitude, CS will be positive."],
   "param"=>
    {"F"=>
      ["[in]",
       "         F is DOUBLE PRECISION",
       "         The first component of vector to be rotated."],
     "G"=>
      ["[in]",
       "         G is DOUBLE PRECISION",
       "         The second component of vector to be rotated."],
     "CS"=>
      ["[out]",
       "         CS is DOUBLE PRECISION",
       "         The cosine of the rotation."],
     "SN"=>
      ["[out]",
       "         SN is DOUBLE PRECISION",
       "         The sine of the rotation."],
     "R"=>
      ["[out]",
       "         R is DOUBLE PRECISION",
       "         The nonzero component of the rotated vector.",
       " This version has a few statements commented out for thread safety",
       " (machine parameters are computed on each entry). 10 feb 03, SJH."]}},
 "zupgtr"=>
  {"summary"=>
    ["ZUPGTR generates a complex unitary matrix Q which is defined as the",
     "product of n-1 elementary reflectors H(i) of order n, as returned by",
     "ZHPTRD using packed storage:",
     "if UPLO = 'U', Q = H(n-1) . . . H(2) H(1),",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(n-1)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangular packed storage used in previous",
       "                call to ZHPTRD;",
       "         = 'L': Lower triangular packed storage used in previous",
       "                call to ZHPTRD."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The vectors which define the elementary reflectors, as",
       "         returned by ZHPTRD."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZHPTRD."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,N)",
       "         The N-by-N unitary matrix Q."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N-1)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sormr2"=>
  {"summary"=>
    ["SORMR2 overwrites the general real m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**T* C  if SIDE = 'L' and TRANS = 'T', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**T if SIDE = 'R' and TRANS = 'T',",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by SGERQF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left",
       "         = 'R': apply Q or Q**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'T': apply Q' (Transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         SGERQF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGERQF."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "spstf2"=>
  {"summary"=>
    ["SPSTF2 computes the Cholesky factorization with complete",
     "pivoting of a real symmetric positive semidefinite matrix A.",
     "The factorization has the form",
     "   P**T * A * P = U**T * U ,  if UPLO = 'U',",
     "   P**T * A * P = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular, and",
     "P is stored as vector PIV.",
     "This algorithm does not attempt to check that A is positive",
     "semidefinite. This version of the algorithm calls level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization as above."],
     "PIV"=>
      ["[out]",
       "         PIV is INTEGER array, dimension (N)",
       "         PIV is such that the nonzero entries are P( PIV(K), K ) = 1."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The rank of A given by the number of steps the algorithm",
       "         completed."],
     "TOL"=>
      ["[in]",
       "         TOL is REAL",
       "         User defined tolerance. If TOL < 0, then N*U*MAX( A( K,K ) )",
       "         will be used. The algorithm terminates at the (K-1)st step",
       "         if the pivot <= TOL."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (2*N)",
       "         Work space."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         < 0: If INFO = -K, the K-th argument had an illegal value,",
       "         = 0: algorithm completed successfully, and",
       "         > 0: the matrix A is either rank deficient with computed rank",
       "              as returned in RANK, or is not positive semidefinite. See",
       "              Section 7 of LAPACK Working Note #161 for further",
       "              information."]}},
 "cungl2"=>
  {"summary"=>
    ["CUNGL2 generates an m-by-n complex matrix Q with orthonormal rows,",
     "which is defined as the first m rows of a product of k elementary",
     "reflectors of order n",
     "      Q  =  H(k)**H . . . H(2)**H H(1)**H",
     "as returned by CGELQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the i-th row must contain the vector which defines",
       "         the elementary reflector H(i), for i = 1,2,...,k, as returned",
       "         by CGELQF in the first k rows of its array argument A.",
       "         On exit, the m by n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGELQF."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "csytri"=>
  {"summary"=>
    ["CSYTRI computes the inverse of a complex symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "CSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "sgelss"=>
  {"summary"=>
    ["SGELSS computes the minimum norm solution to a real linear least",
     "squares problem:",
     "Minimize 2-norm(| b - A*x |).",
     "using the singular value decomposition (SVD) of A. A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix",
     "X.",
     "The effective rank of A is determined by treating as zero those",
     "singular values which are less than RCOND times the largest singular",
     "value."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the first min(m,n) rows of A are overwritten with",
       "         its right singular vectors, stored rowwise."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, B is overwritten by the N-by-NRHS solution",
       "         matrix X.  If m >= n and RANK = n, the residual",
       "         sum-of-squares for the solution in the i-th column is given",
       "         by the sum of squares of elements n+1:m in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,max(M,N))."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (min(M,N))",
       "         The singular values of A in decreasing order.",
       "         The condition number of A in the 2-norm = S(1)/S(min(m,n))."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "         RCOND is used to determine the effective rank of A.",
       "         Singular values S(i) <= RCOND*S(1) are treated as zero.",
       "         If RCOND < 0, machine precision is used instead."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the number of singular values",
       "         which are greater than RCOND*S(1)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= 1, and also:",
       "         LWORK >= 3*min(M,N) + max( 2*min(M,N), max(M,N), NRHS )",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  the algorithm for computing the SVD failed to converge;",
       "               if INFO = i, i off-diagonal elements of an intermediate",
       "               bidiagonal form did not converge to zero."]}},
 "shgeqz"=>
  {"summary"=>
    ["SHGEQZ computes the eigenvalues of a real matrix pair (H,T),",
     "where H is an upper Hessenberg matrix and T is upper triangular,",
     "using the double-shift QZ method.",
     "Matrix pairs of this type are produced by the reduction to",
     "generalized upper Hessenberg form of a real matrix pair (A,B):",
     "   A = Q1*H*Z1**T,  B = Q1*T*Z1**T,",
     "as computed by SGGHRD.",
     "If JOB='S', then the Hessenberg-triangular pair (H,T) is",
     "also reduced to generalized Schur form,",
     "   H = Q*S*Z**T,  T = Q*P*Z**T,",
     "where Q and Z are orthogonal matrices, P is an upper triangular",
     "matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2",
     "diagonal blocks.",
     "The 1-by-1 blocks correspond to real eigenvalues of the matrix pair",
     "(H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of",
     "eigenvalues.",
     "Additionally, the 2-by-2 upper triangular diagonal blocks of P",
     "corresponding to 2-by-2 blocks of S are reduced to positive diagonal",
     "form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0,",
     "P(j,j) > 0, and P(j+1,j+1) > 0.",
     "Optionally, the orthogonal matrix Q from the generalized Schur",
     "factorization may be postmultiplied into an input matrix Q1, and the",
     "orthogonal matrix Z may be postmultiplied into an input matrix Z1.",
     "If Q1 and Z1 are the orthogonal matrices from SGGHRD that reduced",
     "the matrix pair (A,B) to generalized upper Hessenberg form, then the",
     "output matrices Q1*Q and Z1*Z are the orthogonal factors from the",
     "generalized Schur factorization of (A,B):",
     "   A = (Q1*Q)*S*(Z1*Z)**T,  B = (Q1*Q)*P*(Z1*Z)**T.",
     "To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently,",
     "of (A,B)) are computed as a pair of values (alpha,beta), where alpha is",
     "complex and beta real.",
     "If beta is nonzero, lambda = alpha / beta is an eigenvalue of the",
     "generalized nonsymmetric eigenvalue problem (GNEP)",
     "   A*x = lambda*B*x",
     "and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the",
     "alternate form of the GNEP",
     "   mu*A*y = B*y.",
     "Real eigenvalues can be read directly from the generalized Schur",
     "form:",
     "  alpha = S(i,i), beta = P(i,i).",
     "Ref: C.B. Moler & G.W. Stewart, \"An Algorithm for Generalized Matrix",
     "     Eigenvalue Problems\", SIAM J. Numer. Anal., 10(1973),",
     "     pp. 241--256."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         = 'E': Compute eigenvalues only;",
       "         = 'S': Compute eigenvalues and the Schur form."],
     "COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': Left Schur vectors (Q) are not computed;",
       "         = 'I': Q is initialized to the unit matrix and the matrix Q",
       "                of left Schur vectors of (H,T) is returned;",
       "         = 'V': Q must contain an orthogonal matrix Q1 on entry and",
       "                the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': Right Schur vectors (Z) are not computed;",
       "         = 'I': Z is initialized to the unit matrix and the matrix Z",
       "                of right Schur vectors of (H,T) is returned;",
       "         = 'V': Z must contain an orthogonal matrix Z1 on entry and",
       "                the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices H, T, Q, and Z.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of H which are in",
       "         Hessenberg form.  It is assumed that A is already upper",
       "         triangular in rows and columns 1:ILO-1 and IHI+1:N.",
       "         If N > 0, 1 <= ILO <= IHI <= N; if N = 0, ILO=1 and IHI=0."],
     "H"=>
      ["[in,out]",
       "         H is REAL array, dimension (LDH, N)",
       "         On entry, the N-by-N upper Hessenberg matrix H.",
       "         On exit, if JOB = 'S', H contains the upper quasi-triangular",
       "         matrix S from the generalized Schur factorization.",
       "         If JOB = 'E', the diagonal blocks of H match those of S, but",
       "         the rest of H is unspecified."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max( 1, N )."],
     "T"=>
      ["[in,out]",
       "         T is REAL array, dimension (LDT, N)",
       "         On entry, the N-by-N upper triangular matrix T.",
       "         On exit, if JOB = 'S', T contains the upper triangular",
       "         matrix P from the generalized Schur factorization;",
       "         2-by-2 diagonal blocks of P corresponding to 2-by-2 blocks of S",
       "         are reduced to positive diagonal form, i.e., if H(j+1,j) is",
       "         non-zero, then T(j+1,j) = T(j,j+1) = 0, T(j,j) > 0, and",
       "         T(j+1,j+1) > 0.",
       "         If JOB = 'E', the diagonal blocks of T match those of P, but",
       "         the rest of T is unspecified."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max( 1, N )."],
     "ALPHAR"=>
      ["[out]",
       "         ALPHAR is REAL array, dimension (N)",
       "         The real parts of each scalar alpha defining an eigenvalue",
       "         of GNEP."],
     "ALPHAI"=>
      ["[out]",
       "         ALPHAI is REAL array, dimension (N)",
       "         The imaginary parts of each scalar alpha defining an",
       "         eigenvalue of GNEP.",
       "         If ALPHAI(j) is zero, then the j-th eigenvalue is real; if",
       "         positive, then the j-th and (j+1)-st eigenvalues are a",
       "         complex conjugate pair, with ALPHAI(j+1) = -ALPHAI(j)."],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         The scalars beta that define the eigenvalues of GNEP.",
       "         Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and",
       "         beta = BETA(j) represent the j-th eigenvalue of the matrix",
       "         pair (A,B), in one of the forms lambda = alpha/beta or",
       "         mu = beta/alpha.  Since either lambda or mu may overflow,",
       "         they should not, in general, be computed."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the orthogonal matrix Q1 used in",
       "         the reduction of (A,B) to generalized Hessenberg form.",
       "         On exit, if COMPQ = 'I', the orthogonal matrix of left Schur",
       "         vectors of (H,T), and if COMPQ = 'V', the orthogonal matrix",
       "         of left Schur vectors of (A,B).",
       "         Not referenced if COMPQ = 'N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= 1.",
       "         If COMPQ='V' or 'I', then LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the orthogonal matrix Z1 used in",
       "         the reduction of (A,B) to generalized Hessenberg form.",
       "         On exit, if COMPZ = 'I', the orthogonal matrix of",
       "         right Schur vectors of (H,T), and if COMPZ = 'V', the",
       "         orthogonal matrix of right Schur vectors of (A,B).",
       "         Not referenced if COMPZ = 'N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1.",
       "         If COMPZ='V' or 'I', then LDZ >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO >= 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         = 1,...,N: the QZ iteration did not converge.  (H,T) is not",
       "                    in Schur form, but ALPHAR(i), ALPHAI(i), and",
       "                    BETA(i), i=INFO+1,...,N should be correct.",
       "         = N+1,...,2*N: the shift calculation failed.  (H,T) is not",
       "                    in Schur form, but ALPHAR(i), ALPHAI(i), and",
       "                    BETA(i), i=INFO-N+1,...,N should be correct."]}},
 "clasyf"=>
  {"summary"=>
    ["CLASYF computes a partial factorization of a complex symmetric matrix",
     "A using the Bunch-Kaufman diagonal pivoting method. The partial",
     "factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) ( D    0  ) ( L11**T L21**T )  if UPLO = 'L'",
     "      ( L21  I ) ( 0   A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "Note that U**T denotes the transpose of U.",
     "CLASYF is an auxiliary routine called by CSYTRF. It uses blocked code",
     "(calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or",
     "A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "W"=>["[out]", "         W is COMPLEX array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "zheequb"=>
  {"summary"=>
    ["ZHEEQUB computes row and column scalings intended to equilibrate a",
     "Hermitian matrix A (with respect to the Euclidean norm) and reduce",
     "its condition number. The scale factors S are computed by the BIN",
     "algorithm (see references) so that the scaled matrix B with elements",
     "B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of",
     "the smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The N-by-N Hermitian matrix whose scaling factors are to be",
       "         computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is DOUBLE PRECISION",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i). If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Largest absolute value of any matrix element. If AMAX is",
       "         very close to overflow or very close to underflow, the",
       "         matrix should be scaled."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "cunbdb1"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <=",
       "          MIN(P,M-P,M-Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is REAL array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is COMPLEX array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is COMPLEX array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is COMPLEX array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zbbcsd"=>
  {"summary"=>
    ["ZBBCSD computes the CS decomposition of a unitary matrix in",
     "bidiagonal-block form,",
     "    [ B11 | B12 0  0 ]",
     "    [  0  |  0 -I  0 ]",
     "X = [----------------]",
     "    [ B21 | B22 0  0 ]",
     "    [  0  |  0  0  I ]",
     "                              [  C | -S  0  0 ]",
     "                  [ U1 |    ] [  0 |  0 -I  0 ] [ V1 |    ]**H",
     "                = [---------] [---------------] [---------]   .",
     "                  [    | U2 ] [  S |  C  0  0 ] [    | V2 ]",
     "                              [  0 |  0  0  I ]",
     "X is M-by-M, its top-left block is P-by-Q, and Q must be no larger",
     "than P, M-P, or M-Q. (If Q is not the smallest index, then X must be",
     "transposed and/or permuted. This can be done in constant time using",
     "the TRANS and SIGNS options. See ZUNCSD for details.)",
     "The bidiagonal matrices B11, B12, B21, and B22 are represented",
     "implicitly by angles THETA(1:Q) and PHI(1:Q-1).",
     "The unitary matrices U1, U2, V1T, and V2T are input/output.",
     "The input matrices are pre- or post-multiplied by the appropriate",
     "singular vector matrices."],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is updated;",
       "         otherwise:  U1 is not updated."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is updated;",
       "         otherwise:  U2 is not updated."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is updated;",
       "         otherwise:  V1T is not updated."],
     "JOBV2T"=>
      ["[in]",
       "         JOBV2T is CHARACTER",
       "         = 'Y':      V2T is updated;",
       "         otherwise:  V2T is not updated."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X, the unitary matrix in",
       "         bidiagonal-block form."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in the top-left block of X. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in the top-left block of X.",
       "         0 <= Q <= MIN(P,M-P,M-Q)."],
     "THETA"=>
      ["[in,out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "         On entry, the angles THETA(1),...,THETA(Q) that, along with",
       "         PHI(1), ...,PHI(Q-1), define the matrix in bidiagonal-block",
       "         form. On exit, the angles whose cosines and sines define the",
       "         diagonal blocks in the CS decomposition."],
     "PHI"=>
      ["[in,out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "         The angles PHI(1),...,PHI(Q-1) that, along with THETA(1),...,",
       "         THETA(Q), define the matrix in bidiagonal-block form."],
     "U1"=>
      ["[in,out]",
       "         U1 is COMPLEX*16 array, dimension (LDU1,P)",
       "         On entry, a P-by-P matrix. On exit, U1 is postmultiplied",
       "         by the left singular vector matrix common to [ B11 ; 0 ] and",
       "         [ B12 0 0 ; 0 -I 0 0 ]."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of the array U1, LDU1 >= MAX(1,P)."],
     "U2"=>
      ["[in,out]",
       "         U2 is COMPLEX*16 array, dimension (LDU2,M-P)",
       "         On entry, an (M-P)-by-(M-P) matrix. On exit, U2 is",
       "         postmultiplied by the left singular vector matrix common to",
       "         [ B21 ; 0 ] and [ B22 0 0 ; 0 0 I ]."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of the array U2, LDU2 >= MAX(1,M-P)."],
     "V1T"=>
      ["[in,out]",
       "         V1T is COMPLEX*16 array, dimension (LDV1T,Q)",
       "         On entry, a Q-by-Q matrix. On exit, V1T is premultiplied",
       "         by the conjugate transpose of the right singular vector",
       "         matrix common to [ B11 ; 0 ] and [ B21 ; 0 ]."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of the array V1T, LDV1T >= MAX(1,Q)."],
     "V2T"=>
      ["[in,out]",
       "         V2T is COMPLEX*16 array, dimenison (LDV2T,M-Q)",
       "         On entry, an (M-Q)-by-(M-Q) matrix. On exit, V2T is",
       "         premultiplied by the conjugate transpose of the right",
       "         singular vector matrix common to [ B12 0 0 ; 0 -I 0 ] and",
       "         [ B22 0 0 ; 0 0 I ]."],
     "LDV2T"=>
      ["[in]",
       "         LDV2T is INTEGER",
       "         The leading dimension of the array V2T, LDV2T >= MAX(1,M-Q)."],
     "B11D"=>
      ["[out]",
       "         B11D is DOUBLE PRECISION array, dimension (Q)",
       "         When ZBBCSD converges, B11D contains the cosines of THETA(1),",
       "         ..., THETA(Q). If ZBBCSD fails to converge, then B11D",
       "         contains the diagonal of the partially reduced top-left",
       "         block."],
     "B11E"=>
      ["[out]",
       "         B11E is DOUBLE PRECISION array, dimension (Q-1)",
       "         When ZBBCSD converges, B11E contains zeros. If ZBBCSD fails",
       "         to converge, then B11E contains the superdiagonal of the",
       "         partially reduced top-left block."],
     "B12D"=>
      ["[out]",
       "         B12D is DOUBLE PRECISION array, dimension (Q)",
       "         When ZBBCSD converges, B12D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If ZBBCSD fails to converge, then",
       "         B12D contains the diagonal of the partially reduced top-right",
       "         block."],
     "B12E"=>
      ["[out]",
       "         B12E is DOUBLE PRECISION array, dimension (Q-1)",
       "         When ZBBCSD converges, B12E contains zeros. If ZBBCSD fails",
       "         to converge, then B12E contains the subdiagonal of the",
       "         partially reduced top-right block."],
     "B21D"=>
      ["[out]",
       "         B21D is DOUBLE PRECISION array, dimension (Q)",
       "         When ZBBCSD converges, B21D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If ZBBCSD fails to converge, then",
       "         B21D contains the diagonal of the partially reduced bottom-left",
       "         block."],
     "B21E"=>
      ["[out]",
       "         B21E is DOUBLE PRECISION array, dimension (Q-1)",
       "         When ZBBCSD converges, B21E contains zeros. If ZBBCSD fails",
       "         to converge, then B21E contains the subdiagonal of the",
       "         partially reduced bottom-left block."],
     "B22D"=>
      ["[out]",
       "         B22D is DOUBLE PRECISION array, dimension (Q)",
       "         When ZBBCSD converges, B22D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If ZBBCSD fails to converge, then",
       "         B22D contains the diagonal of the partially reduced bottom-right",
       "         block."],
     "B22E"=>
      ["[out]",
       "         B22E is DOUBLE PRECISION array, dimension (Q-1)",
       "         When ZBBCSD converges, B22E contains zeros. If ZBBCSD fails",
       "         to converge, then B22E contains the subdiagonal of the",
       "         partially reduced bottom-right block."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK. LRWORK >= MAX(1,8*Q).",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the RWORK array,",
       "         returns this value as the first entry of the work array, and",
       "         no error message related to LRWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if ZBBCSD did not converge, INFO specifies the number",
       "               of nonzero entries in PHI, and B11D, B11E, etc.,",
       "               contain the partially reduced matrix."]}},
 "dgbequb"=>
  {"summary"=>
    ["DGBEQUB computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most",
     "the radix.",
     "R(i) and C(j) are restricted to be a power of the radix between",
     "SMLNUM = smallest safe number and BIGNUM = largest safe number.  Use",
     "of these scaling factors is not guaranteed to reduce the condition",
     "number of A but works well in practice.",
     "This routine differs from DGEEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled entries' magnitudes are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A.  LDAB >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is DOUBLE PRECISION",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is DOUBLE PRECISION",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "spstrf"=>
  {"summary"=>
    ["SPSTRF computes the Cholesky factorization with complete",
     "pivoting of a real symmetric positive semidefinite matrix A.",
     "The factorization has the form",
     "   P**T * A * P = U**T * U ,  if UPLO = 'U',",
     "   P**T * A * P = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular, and",
     "P is stored as vector PIV.",
     "This algorithm does not attempt to check that A is positive",
     "semidefinite. This version of the algorithm calls level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization as above."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "PIV"=>
      ["[out]",
       "         PIV is INTEGER array, dimension (N)",
       "         PIV is such that the nonzero entries are P( PIV(K), K ) = 1."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The rank of A given by the number of steps the algorithm",
       "         completed."],
     "TOL"=>
      ["[in]",
       "         TOL is REAL",
       "         User defined tolerance. If TOL < 0, then N*U*MAX( A(K,K) )",
       "         will be used. The algorithm terminates at the (K-1)st step",
       "         if the pivot <= TOL."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (2*N)",
       "         Work space."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         < 0: If INFO = -K, the K-th argument had an illegal value,",
       "         = 0: algorithm completed successfully, and",
       "         > 0: the matrix A is either rank deficient with computed rank",
       "              as returned in RANK, or is not positive semidefinite. See",
       "              Section 7 of LAPACK Working Note #161 for further",
       "              information."]}},
 "zpftrf"=>
  {"summary"=>
    ["ZPFTRF computes the Cholesky factorization of a complex Hermitian",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the block version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of RFP A is stored;",
       "         = 'L':  Lower triangle of RFP A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension ( N*(N+1)/2 );",
       "         On entry, the Hermitian matrix A in RFP format. RFP format is",
       "         described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'",
       "         then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'C' then RFP is",
       "         the Conjugate-transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the nt elements of",
       "         upper packed A. If UPLO = 'L' the RFP A contains the elements",
       "         of lower packed A. The LDA of RFP A is (N+1)/2 when TRANSR =",
       "         'C'. When TRANSR is 'N' the LDA is N+1 when N is even and N",
       "         is odd. See the Note below for more details.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization RFP A = U**H*U or RFP A = L*L**H."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed.",
       " Further Notes on RFP Format:",
       " ============================",
       " We first consider Standard Packed Format when N is even.",
       " We give an example where N = 6.",
       "    AP is Upper             AP is Lower",
       "  00 01 02 03 04 05       00",
       "     11 12 13 14 15       10 11",
       "        22 23 24 25       20 21 22",
       "           33 34 35       30 31 32 33",
       "              44 45       40 41 42 43 44",
       "                 55       50 51 52 53 54 55",
       " Let TRANSR = 'N'. RFP holds AP as follows:",
       " For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last",
       " three columns of AP upper. The lower triangle A(4:6,0:2) consists of",
       " conjugate-transpose of the first three columns of AP upper.",
       " For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first",
       " three columns of AP lower. The upper triangle A(0:2,0:2) consists of",
       " conjugate-transpose of the last three columns of AP lower.",
       " To denote conjugate we place -- above the element. This covers the",
       " case N even and TRANSR = 'N'.",
       "        RFP A                   RFP A",
       "                               -- -- --",
       "       03 04 05                33 43 53",
       "                                  -- --",
       "       13 14 15                00 44 54",
       "                                     --",
       "       23 24 25                10 11 55",
       "       33 34 35                20 21 22",
       "       --",
       "       00 44 45                30 31 32",
       "       -- --",
       "       01 11 55                40 41 42",
       "       -- -- --",
       "       02 12 22                50 51 52",
       " Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-",
       " transpose of RFP A above. One therefore gets:",
       "          RFP A                   RFP A",
       "    -- -- -- --                -- -- -- -- -- --",
       "    03 13 23 33 00 01 02    33 00 10 20 30 40 50",
       "    -- -- -- -- --                -- -- -- -- --",
       "    04 14 24 34 44 11 12    43 44 11 21 31 41 51",
       "    -- -- -- -- -- --                -- -- -- --",
       "    05 15 25 35 45 55 22    53 54 55 22 32 42 52",
       " We next  consider Standard Packed Format when N is odd.",
       " We give an example where N = 5.",
       "    AP is Upper                 AP is Lower",
       "  00 01 02 03 04              00",
       "     11 12 13 14              10 11",
       "        22 23 24              20 21 22",
       "           33 34              30 31 32 33",
       "              44              40 41 42 43 44",
       " Let TRANSR = 'N'. RFP holds AP as follows:",
       " For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last",
       " three columns of AP upper. The lower triangle A(3:4,0:1) consists of",
       " conjugate-transpose of the first two   columns of AP upper.",
       " For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first",
       " three columns of AP lower. The upper triangle A(0:1,1:2) consists of",
       " conjugate-transpose of the last two   columns of AP lower.",
       " To denote conjugate we place -- above the element. This covers the",
       " case N odd  and TRANSR = 'N'.",
       "        RFP A                   RFP A",
       "                                  -- --",
       "       02 03 04                00 33 43",
       "                                     --",
       "       12 13 14                10 11 44",
       "       22 23 24                20 21 22",
       "       --",
       "       00 33 34                30 31 32",
       "       -- --",
       "       01 11 44                40 41 42",
       " Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-",
       " transpose of RFP A above. One therefore gets:",
       "          RFP A                   RFP A",
       "    -- -- --                   -- -- -- -- -- --",
       "    02 12 22 00 01             00 10 20 30 40 50",
       "    -- -- -- --                   -- -- -- -- --",
       "    03 13 23 33 11             33 11 21 31 41 51",
       "    -- -- -- -- --                   -- -- -- --",
       "    04 14 24 34 44             43 44 22 32 42 52"]}},
 "zheevr"=>
  {"summary"=>
    ["ZHEEVR computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian matrix A.  Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues.",
     "ZHEEVR first reduces the matrix A to tridiagonal form T with a call",
     "to ZHETRD.  Then, whenever possible, ZHEEVR calls ZSTEMR to compute",
     "eigenspectrum using Relatively Robust Representations.  ZSTEMR",
     "computes eigenvalues by the dqds algorithm, while orthogonal",
     "eigenvectors are computed from various \"good\" L D L^T representations",
     "(also known as Relatively Robust Representations). Gram-Schmidt",
     "orthogonalization is avoided as far as possible. More specifically,",
     "the various steps of the algorithm are as follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "The desired accuracy of the output can be specified by the input",
     "parameter ABSTOL.",
     "For more details, see DSTEMR's documentation and:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Note 1 : ZHEEVR calls ZSTEMR when the full spectrum is requested",
     "on machines which conform to the ieee-754 floating point standard.",
     "ZHEEVR calls DSTEBZ and ZSTEIN on non-ieee machines and",
     "when partial spectrum requests are made.",
     "Normal execution of ZSTEMR may create NaNs and infinities and",
     "hence may abort due to a floating point exception in environments",
     "which do not handle NaNs and infinities in the ieee standard default",
     "manner."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found.",
       "         For RANGE = 'V' or 'I' and IU - IL < N - 1, DSTEBZ and",
       "         ZSTEIN are called"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3.",
       "         If high relative accuracy is important, set ABSTOL to",
       "         DLAMCH( 'Safe minimum' ).  Doing so will guarantee that",
       "         eigenvalues are computed to high relative accuracy when",
       "         possible in future releases.  The current code does not",
       "         make any guarantees about high relative accuracy, but",
       "         furutre releases will. See J. Barlow and J. Demmel,",
       "         \"Computing Accurate Eigensystems of Scaled Diagonally",
       "         Dominant Matrices\", LAPACK Working Note #7, for a discussion",
       "         of which matrices define their eigenvalues to high relative",
       "         accuracy."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is an output of ZSTEMR (tridiagonal",
       "         matrix). The support of the eigenvectors of A is typically",
       "         1:N because of the unitary transformations applied by ZUNMTR.",
       "         Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1"],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,2*N).",
       "         For optimal efficiency, LWORK >= (NB+1)*N,",
       "         where NB is the max of the blocksize for ZHETRD and for",
       "         ZUNMTR as returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal",
       "         (and minimal) LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The length of the array RWORK.  LRWORK >= max(1,24*N).",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal",
       "         (and minimal) LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  Internal error"]}},
 "dorgbr"=>
  {"summary"=>
    ["DORGBR generates one of the real orthogonal matrices Q or P**T",
     "determined by DGEBRD when reducing a real matrix A to bidiagonal",
     "form: A = Q * B * P**T.  Q and P**T are defined as products of",
     "elementary reflectors H(i) or G(i) respectively.",
     "If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q",
     "is of order M:",
     "if m >= k, Q = H(1) H(2) . . . H(k) and DORGBR returns the first n",
     "columns of Q, where m >= n >= k;",
     "if m < k, Q = H(1) H(2) . . . H(m-1) and DORGBR returns Q as an",
     "M-by-M matrix.",
     "If VECT = 'P', A is assumed to have been a K-by-N matrix, and P**T",
     "is of order N:",
     "if k < n, P**T = G(k) . . . G(2) G(1) and DORGBR returns the first m",
     "rows of P**T, where n >= m >= k;",
     "if k >= n, P**T = G(n-1) . . . G(2) G(1) and DORGBR returns P**T as",
     "an N-by-N matrix."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         Specifies whether the matrix Q or the matrix P**T is",
       "         required, as defined in the transformation applied by DGEBRD:",
       "         = 'Q':  generate Q;",
       "         = 'P':  generate P**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q or P**T to be returned.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q or P**T to be returned.",
       "         N >= 0.",
       "         If VECT = 'Q', M >= N >= min(M,K);",
       "         if VECT = 'P', N >= M >= min(N,K)."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         If VECT = 'Q', the number of columns in the original M-by-K",
       "         matrix reduced by DGEBRD.",
       "         If VECT = 'P', the number of rows in the original K-by-N",
       "         matrix reduced by DGEBRD.",
       "         K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by DGEBRD.",
       "         On exit, the M-by-N matrix Q or P**T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension",
       "                               (min(M,K)) if VECT = 'Q'",
       "                               (min(N,K)) if VECT = 'P'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i) or G(i), which determines Q or P**T, as",
       "         returned by DGEBRD in its array argument TAUQ or TAUP."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,min(M,N)).",
       "         For optimum performance LWORK >= min(M,N)*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zla_heamv"=>
  {"summary"=>
    ["ZLA_SYAMV  performs the matrix-vector operation",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "n by n symmetric matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is INTEGER",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array A is to be referenced as",
       "          follows:",
       "             UPLO = BLAS_UPPER   Only the upper triangular part of A",
       "                                 is to be referenced.",
       "             UPLO = BLAS_LOWER   Only the lower triangular part of A",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION .",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, DIMENSION ( LDA, n ).",
       "          Before entry, the leading m by n part of the array A must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, n ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, DIMENSION at least",
       "          ( 1 + ( n - 1 )*abs( INCX ) )",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION .",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCY ) )",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit."]}},
 "slansy"=>
  {"summary"=>
    ["SLANSY  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "real symmetric matrix A.",
     "   SLANSY = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANSY as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is to be referenced.",
       "         = 'U':  Upper triangular part of A is referenced",
       "         = 'L':  Lower triangular part of A is referenced"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, SLANSY is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The symmetric matrix A.  If UPLO = 'U', the leading n by n",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading n by n lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "zgbequ"=>
  {"summary"=>
    ["ZGBEQU computes row and column scalings intended to equilibrate an",
     "M-by-N band matrix A and reduce its condition number.  R returns the",
     "row scale factors and C the column scale factors, chosen to try to",
     "make the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.",
     "R(i) and C(j) are restricted to be between SMLNUM = smallest safe",
     "number and BIGNUM = largest safe number.  Use of these scaling",
     "factors is not guaranteed to reduce the condition number of A but",
     "works well in practice."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The band matrix A, stored in rows 1 to KL+KU+1.  The j-th",
       "         column of A is stored in the j-th column of the array AB as",
       "         follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "R"=>
      ["[out]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         If INFO = 0, or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is DOUBLE PRECISION",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is DOUBLE PRECISION",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "dsytrf_rook"=>
  {"summary"=>
    ["DSYTRF_ROOK computes the factorization of a real symmetric matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method.",
     "The form of the factorization is",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k-1 and -IPIV(k-1) were inerchaged,",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k+1 and -IPIV(k+1) were inerchaged,",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "csytrf_rook"=>
  {"summary"=>
    ["CSYTRF_ROOK computes the factorization of a complex symmetric matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method.",
     "The form of the factorization is",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k-1 and -IPIV(k-1) were inerchaged,",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k+1 and -IPIV(k+1) were inerchaged,",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK)).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "sla_syrfsx_extended"=>
  {"summary"=>
    ["SLA_SYRFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by SSYRFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by SSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by SSYTRF."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by SSYTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is REAL array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by SLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is REAL array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is REAL array, dimension (N)",
       "    Workspace. This can be the same workspace passed for Y_TAIL."],
     "DY"=>
      ["[in]",
       "         DY is REAL array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is REAL array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is REAL",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is REAL",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to SLA_SYRFSX_EXTENDED had an illegal",
       "            value"]}},
 "zhetri2x"=>
  {"summary"=>
    ["ZHETRI2X computes the inverse of a COMPLEX*16 Hermitian indefinite matrix",
     "A using the factorization A = U*D*U**H or A = L*D*L**H computed by",
     "ZHETRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the NNB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by ZHETRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NNB structure of D",
       "         as determined by ZHETRF."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX*16 array, dimension (N+NB+1,NB+3)"],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "zlanhb"=>
  {"summary"=>
    ["ZLANHB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n hermitian band matrix A,  with k super-diagonals.",
     "   ZLANHB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANHB as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         band matrix A is supplied.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANHB is",
       "         set to zero."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of super-diagonals or sub-diagonals of the",
       "         band matrix A.  K >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The upper or lower triangle of the hermitian band matrix A,",
       "         stored in the first K+1 rows of AB.  The j-th column of A is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)   = A(i,j) for j<=i<=min(n,j+k).",
       "         Note that the imaginary parts of the diagonal elements need",
       "         not be set and are assumed to be zero."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= K+1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "cstedc"=>
  {"summary"=>
    ["CSTEDC computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric tridiagonal matrix using the divide and conquer method.",
     "The eigenvectors of a full or band complex Hermitian matrix can also",
     "be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this",
     "matrix to tridiagonal form.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none.  See SLAED3 for details."],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'I':  Compute eigenvectors of tridiagonal matrix also.",
       "         = 'V':  Compute eigenvectors of original Hermitian matrix",
       "                 also.  On entry, Z contains the unitary matrix used",
       "                 to reduce the original matrix to tridiagonal form."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the diagonal elements of the tridiagonal matrix.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the subdiagonal elements of the tridiagonal matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ,N)",
       "         On entry, if COMPZ = 'V', then Z contains the unitary",
       "         matrix used in the reduction to tridiagonal form.",
       "         On exit, if INFO = 0, then if COMPZ = 'V', Z contains the",
       "         orthonormal eigenvectors of the original Hermitian matrix,",
       "         and if COMPZ = 'I', Z contains the orthonormal eigenvectors",
       "         of the symmetric tridiagonal matrix.",
       "         If  COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1.",
       "         If eigenvectors are desired, then LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If COMPZ = 'N' or 'I', or N <= 1, LWORK must be at least 1.",
       "         If COMPZ = 'V' and N > 1, LWORK must be at least N*N.",
       "         Note that for COMPZ = 'V', then if N is less than or",
       "         equal to the minimum divide size, usually 25, then LWORK need",
       "         only be 1.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If COMPZ = 'N' or N <= 1, LRWORK must be at least 1.",
       "         If COMPZ = 'V' and N > 1, LRWORK must be at least",
       "                        1 + 3*N + 2*N*lg N + 4*N**2 ,",
       "                        where lg( N ) = smallest integer k such",
       "                        that 2**k >= N.",
       "         If COMPZ = 'I' and N > 1, LRWORK must be at least",
       "                        1 + 4*N + 2*N**2 .",
       "         Note that for COMPZ = 'I' or 'V', then if N is less than or",
       "         equal to the minimum divide size, usually 25, then LRWORK",
       "         need only be max(1,2*(N-1)).",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If COMPZ = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If COMPZ = 'V' or N > 1,  LIWORK must be at least",
       "                                   6 + 6*N + 5*N*lg N.",
       "         If COMPZ = 'I' or N > 1,  LIWORK must be at least",
       "                                   3 + 5*N .",
       "         Note that for COMPZ = 'I' or 'V', then if N is less than or",
       "         equal to the minimum divide size, usually 25, then LIWORK",
       "         need only be 1.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The algorithm failed to compute an eigenvalue while",
       "               working on the submatrix lying in rows and columns",
       "               INFO/(N+1) through mod(INFO,N+1)."]}},
 "slasq2"=>
  {"summary"=>
    ["SLASQ2 computes all the eigenvalues of the symmetric positive",
     "definite tridiagonal matrix associated with the qd array Z to high",
     "relative accuracy are computed to high relative accuracy, in the",
     "absence of denormalization, underflow and overflow.",
     "To see the relation of Z to the tridiagonal matrix, let L be a",
     "unit lower bidiagonal matrix with subdiagonals Z(2,4,6,,..) and",
     "let U be an upper bidiagonal matrix with 1's above and diagonal",
     "Z(1,3,5,,..). The tridiagonal is L*U or, if you prefer, the",
     "symmetric tridiagonal to which it is similar.",
     "Note : SLASQ2 defines a logical variable, IEEE, which is true",
     "on machines which follow ieee-754 floating-point standard in their",
     "handling of infinities and NaNs, and false otherwise. This variable",
     "is passed to SLASQ3."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "       The number of rows and columns in the matrix. N >= 0."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension ( 4*N )",
       "       On entry Z holds the qd array. On exit, entries 1 to N hold",
       "       the eigenvalues in decreasing order, Z( 2*N+1 ) holds the",
       "       trace, and Z( 2*N+2 ) holds the sum of the eigenvalues. If",
       "       N > 2, then Z( 2*N+3 ) holds the iteration count, Z( 2*N+4 )",
       "       holds NDIVS/NIN^2, and Z( 2*N+5 ) holds the percentage of",
       "       shifts that failed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "       = 0: successful exit",
       "       < 0: if the i-th argument is a scalar and had an illegal",
       "            value, then INFO = -i, if the i-th argument is an",
       "            array and the j-entry had an illegal value, then",
       "            INFO = -(i*100+j)",
       "       > 0: the algorithm failed",
       "             = 1, a split was marked by a positive value in E",
       "             = 2, current block of Z not diagonalized after 100*N",
       "                  iterations (in inner while loop).  On exit Z holds",
       "                  a qd array with the same eigenvalues as the given Z.",
       "             = 3, termination criterion of outer while loop not met",
       "                  (program created more than N unreduced blocks)"]}},
 "dgees"=>
  {"summary"=>
    ["DGEES computes for an N-by-N real nonsymmetric matrix A, the",
     "eigenvalues, the real Schur form T, and, optionally, the matrix of",
     "Schur vectors Z.  This gives the Schur factorization A = Z*T*(Z**T).",
     "Optionally, it also orders the eigenvalues on the diagonal of the",
     "real Schur form so that selected eigenvalues are at the top left.",
     "The leading columns of Z then form an orthonormal basis for the",
     "invariant subspace corresponding to the selected eigenvalues.",
     "A matrix is in real Schur form if it is upper quasi-triangular with",
     "1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in the",
     "form",
     "        [  a  b  ]",
     "        [  c  a  ]",
     "where b*c < 0. The eigenvalues of such a block are a +- sqrt(bc)."],
   "param"=>
    {"JOBVS"=>
      ["[in]",
       "         JOBVS is CHARACTER*1",
       "         = 'N': Schur vectors are not computed;",
       "         = 'V': Schur vectors are computed."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the Schur form.",
       "         = 'N': Eigenvalues are not ordered;",
       "         = 'S': Eigenvalues are ordered (see SELECT)."],
     "SELECT"=>
      ["[in]",
       "         SELECT is a LOGICAL FUNCTION of two DOUBLE PRECISION arguments",
       "         SELECT must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'S', SELECT is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         If SORT = 'N', SELECT is not referenced.",
       "         An eigenvalue WR(j)+sqrt(-1)*WI(j) is selected if",
       "         SELECT(WR(j),WI(j)) is true; i.e., if either one of a complex",
       "         conjugate pair of eigenvalues is selected, then both complex",
       "         eigenvalues are selected.",
       "         Note that a selected complex eigenvalue may no longer",
       "         satisfy SELECT(WR(j),WI(j)) = .TRUE. after ordering, since",
       "         ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned); in this",
       "         case INFO is set to N+2 (see INFO below)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten by its real Schur form T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "                        for which SELECT is true. (Complex conjugate",
       "                        pairs for which SELECT is true for either",
       "                        eigenvalue count as 2.)"],
     "WR"=>["[out]", "         WR is DOUBLE PRECISION array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is DOUBLE PRECISION array, dimension (N)",
       "         WR and WI contain the real and imaginary parts,",
       "         respectively, of the computed eigenvalues in the same order",
       "         that they appear on the diagonal of the output Schur form T.",
       "         Complex conjugate pairs of eigenvalues will appear",
       "         consecutively with the eigenvalue having the positive",
       "         imaginary part first."],
     "VS"=>
      ["[out]",
       "         VS is DOUBLE PRECISION array, dimension (LDVS,N)",
       "         If JOBVS = 'V', VS contains the orthogonal matrix Z of Schur",
       "         vectors.",
       "         If JOBVS = 'N', VS is not referenced."],
     "LDVS"=>
      ["[in]",
       "         LDVS is INTEGER",
       "         The leading dimension of the array VS.  LDVS >= 1; if",
       "         JOBVS = 'V', LDVS >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,3*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value.",
       "         > 0: if INFO = i, and i is",
       "            <= N: the QR algorithm failed to compute all the",
       "                  eigenvalues; elements 1:ILO-1 and i+1:N of WR and WI",
       "                  contain those eigenvalues which have converged; if",
       "                  JOBVS = 'V', VS contains the matrix which reduces A",
       "                  to its partially converged Schur form.",
       "            = N+1: the eigenvalues could not be reordered because some",
       "                  eigenvalues were too close to separate (the problem",
       "                  is very ill-conditioned);",
       "            = N+2: after reordering, roundoff changed values of some",
       "                  complex eigenvalues so that leading eigenvalues in",
       "                  the Schur form no longer satisfy SELECT=.TRUE.  This",
       "                  could also be caused by underflow due to scaling."]}},
 "cgbequ"=>
  {"summary"=>
    ["CGBEQU computes row and column scalings intended to equilibrate an",
     "M-by-N band matrix A and reduce its condition number.  R returns the",
     "row scale factors and C the column scale factors, chosen to try to",
     "make the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.",
     "R(i) and C(j) are restricted to be between SMLNUM = smallest safe",
     "number and BIGNUM = largest safe number.  Use of these scaling",
     "factors is not guaranteed to reduce the condition number of A but",
     "works well in practice."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The band matrix A, stored in rows 1 to KL+KU+1.  The j-th",
       "         column of A is stored in the j-th column of the array AB as",
       "         follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "R"=>
      ["[out]",
       "         R is REAL array, dimension (M)",
       "         If INFO = 0, or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is REAL array, dimension (N)",
       "         If INFO = 0, C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is REAL",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is REAL",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "sgttrs"=>
  {"summary"=>
    ["SGTTRS solves one of the systems of equations",
     "   A*X = B  or  A**T*X = B,",
     "with a tridiagonal matrix A using the LU factorization computed",
     "by SGTTRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations.",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T* X = B  (Transpose)",
       "         = 'C':  A**T* X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is REAL array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is REAL array, dimension (N-1)",
       "         The (n-1) elements of the first super-diagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is REAL array, dimension (N-2)",
       "         The (n-2) elements of the second super-diagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the matrix of right hand side vectors B.",
       "         On exit, B is overwritten by the solution vectors X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cungrq"=>
  {"summary"=>
    ["CUNGRQ generates an M-by-N complex matrix Q with orthonormal rows,",
     "which is defined as the last M rows of a product of K elementary",
     "reflectors of order N",
     "      Q  =  H(1)**H H(2)**H . . . H(k)**H",
     "as returned by CGERQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the (m-k+i)-th row must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by CGERQF in the last k rows of its array argument",
       "         A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGERQF."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "sgtsvx"=>
  {"summary"=>
    ["SGTSVX uses the LU factorization to compute the solution to a real",
     "system of linear equations A * X = B or A**T * X = B,",
     "where A is a tridiagonal matrix of order N and X and B are N-by-NRHS",
     "matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "csysv"=>
  {"summary"=>
    ["CSYSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.  The factored form of A is then",
     "used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**T or A = L*D*L**T as computed by",
       "         CSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by CSYTRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         CSYTRF.",
       "         for LWORK < N, TRS will be done with Level BLAS 2",
       "         for LWORK >= N, TRS will be done with Level BLAS 3",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "dgglse"=>
  {"summary"=>
    ["DGGLSE solves the linear equality-constrained least squares (LSE)",
     "problem:",
     "        minimize || c - A*x ||_2   subject to   B*x = d",
     "where A is an M-by-N matrix, B is a P-by-N matrix, c is a given",
     "M-vector, and d is a given P-vector. It is assumed that",
     "P <= N <= M+P, and",
     "         rank(B) = P and  rank( (A) ) = N.",
     "                              ( (B) )",
     "These conditions ensure that the LSE problem has a unique solution,",
     "which is obtained using a generalized RQ factorization of the",
     "matrices (B, A) given by",
     "   B = (0 R)*Q,   A = Z*T*Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B. N >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B. 0 <= P <= N <= M+P."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, the upper triangle of the subarray B(1:P,N-P+1:N)",
       "         contains the P-by-P upper triangular matrix R."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (M)",
       "         On entry, C contains the right hand side vector for the",
       "         least squares part of the LSE problem.",
       "         On exit, the residual sum of squares for the solution",
       "         is given by the sum of squares of elements N-P+1 to M of",
       "         vector C."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (P)",
       "         On entry, D contains the right hand side vector for the",
       "         constrained equation.",
       "         On exit, D is destroyed."],
     "X"=>
      ["[out]",
       "         X is DOUBLE PRECISION array, dimension (N)",
       "         On exit, X is the solution of the LSE problem."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M+N+P).",
       "         For optimum performance LWORK >= P+min(M,N)+max(M,N)*NB,",
       "         where NB is an upper bound for the optimal blocksizes for",
       "         DGEQRF, SGERQF, DORMQR and SORMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the upper triangular factor R associated with B in the",
       "               generalized RQ factorization of the pair (B, A) is",
       "               singular, so that rank(B) < P; the least squares",
       "               solution could not be computed.",
       "         = 2:  the (N-P) by (N-P) part of the upper trapezoidal factor",
       "               T associated with A in the generalized RQ factorization",
       "               of the pair (B, A) is singular, so that",
       "               rank( (A) ) < N; the least squares solution could not",
       "                   ( (B) )",
       "               be computed."]}},
 "chetrs_aa"=>
  {"summary"=>
    ["CHETRS_AA solves a system of linear equations A*X = B with a complex",
     "hermitian matrix A using the factorization A = U*T*U**H or",
     "A = L*T*L**H computed by CHETRF_AA."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*T*U**H;",
       "         = 'L':  Lower triangular, form is A = L*T*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         Details of factors computed by CHETRF_AA."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges as computed by CHETRF_AA."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[in]", "         WORK is DOUBLE array, dimension (MAX(1,LWORK))"],
     "LWORK"=>["[in]", "         LWORK is INTEGER, LWORK >= MAX(1,3*N-2)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dpstf2"=>
  {"summary"=>
    ["DPSTF2 computes the Cholesky factorization with complete",
     "pivoting of a real symmetric positive semidefinite matrix A.",
     "The factorization has the form",
     "   P**T * A * P = U**T * U ,  if UPLO = 'U',",
     "   P**T * A * P = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular, and",
     "P is stored as vector PIV.",
     "This algorithm does not attempt to check that A is positive",
     "semidefinite. This version of the algorithm calls level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization as above."],
     "PIV"=>
      ["[out]",
       "         PIV is INTEGER array, dimension (N)",
       "         PIV is such that the nonzero entries are P( PIV(K), K ) = 1."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The rank of A given by the number of steps the algorithm",
       "         completed."],
     "TOL"=>
      ["[in]",
       "         TOL is DOUBLE PRECISION",
       "         User defined tolerance. If TOL < 0, then N*U*MAX( A( K,K ) )",
       "         will be used. The algorithm terminates at the (K-1)st step",
       "         if the pivot <= TOL."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (2*N)",
       "         Work space."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         < 0: If INFO = -K, the K-th argument had an illegal value,",
       "         = 0: algorithm completed successfully, and",
       "         > 0: the matrix A is either rank deficient with computed rank",
       "              as returned in RANK, or is not positive semidefinite. See",
       "              Section 7 of LAPACK Working Note #161 for further",
       "              information."]}},
 "dgetsls"=>
  {"summary"=>
    ["DGETSLS solves overdetermined or underdetermined real linear systems",
     "involving an M-by-N matrix A, using a tall skinny QR or short wide LQ",
     "factorization of A.  It is assumed that A has full rank.",
     "The following options are provided:",
     "1. If TRANS = 'N' and m >= n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A*X ||.",
     "2. If TRANS = 'N' and m < n:  find the minimum norm solution of",
     "   an underdetermined system A * X = B.",
     "3. If TRANS = 'T' and m >= n:  find the minimum norm solution of",
     "   an undetermined system A**T * X = B.",
     "4. If TRANS = 'T' and m < n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A**T * X ||.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': the linear system involves A;",
       "         = 'T': the linear system involves A**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of the matrices B and X. NRHS >=0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         A is overwritten by details of its QR or LQ",
       "         factorization as returned by DGEQR or DGELQ."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the matrix B of right hand side vectors, stored",
       "         columnwise; B is M-by-NRHS if TRANS = 'N', or N-by-NRHS",
       "         if TRANS = 'T'.",
       "         On exit, if INFO = 0, B is overwritten by the solution",
       "         vectors, stored columnwise:",
       "         if TRANS = 'N' and m >= n, rows 1 to n of B contain the least",
       "         squares solution vectors.",
       "         if TRANS = 'N' and m < n, rows 1 to N of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'T' and m >= n, rows 1 to M of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'T' and m < n, rows 1 to M of B contain the",
       "         least squares solution vectors."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= MAX(1,M,N)."],
     "WORK"=>
      ["[out]",
       "         (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO =  i, the i-th diagonal element of the",
       "               triangular factor of A is zero, so that A does not have",
       "               full rank; the least squares solution could not be",
       "               computed."]}},
 "zposvxx"=>
  {"summary"=>
    ["   ZPOSVXX uses the Cholesky factorization A = U**T*U or A = L*L**T",
     "   to compute the solution to a complex*16 system of linear equations",
     "   A * X = B, where A is an N-by-N symmetric positive definite matrix",
     "   and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. ZPOSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   ZPOSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   ZPOSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what ZPOSVXX would itself produce."],
   "param"=>nil},
 "clasr"=>
  {"summary"=>
    ["CLASR applies a sequence of real plane rotations to a complex matrix",
     "A, from either the left or the right.",
     "When SIDE = 'L', the transformation takes the form",
     "   A := P*A",
     "and when SIDE = 'R', the transformation takes the form",
     "   A := A*P**T",
     "where P is an orthogonal matrix consisting of a sequence of z plane",
     "rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R',",
     "and P**T is the transpose of P.",
     "When DIRECT = 'F' (Forward sequence), then",
     "   P = P(z-1) * ... * P(2) * P(1)",
     "and when DIRECT = 'B' (Backward sequence), then",
     "   P = P(1) * P(2) * ... * P(z-1)",
     "where P(k) is a plane rotation matrix defined by the 2-by-2 rotation",
     "   R(k) = (  c(k)  s(k) )",
     "        = ( -s(k)  c(k) ).",
     "When PIVOT = 'V' (Variable pivot), the rotation is performed",
     "for the plane (k,k+1), i.e., P(k) has the form",
     "   P(k) = (  1                                            )",
     "          (       ...                                     )",
     "          (              1                                )",
     "          (                   c(k)  s(k)                  )",
     "          (                  -s(k)  c(k)                  )",
     "          (                                1              )",
     "          (                                     ...       )",
     "          (                                            1  )",
     "where R(k) appears as a rank-2 modification to the identity matrix in",
     "rows and columns k and k+1.",
     "When PIVOT = 'T' (Top pivot), the rotation is performed for the",
     "plane (1,k+1), so P(k) has the form",
     "   P(k) = (  c(k)                    s(k)                 )",
     "          (         1                                     )",
     "          (              ...                              )",
     "          (                     1                         )",
     "          ( -s(k)                    c(k)                 )",
     "          (                                 1             )",
     "          (                                      ...      )",
     "          (                                             1 )",
     "where R(k) appears in rows and columns 1 and k+1.",
     "Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is",
     "performed for the plane (k,z), giving P(k) the form",
     "   P(k) = ( 1                                             )",
     "          (      ...                                      )",
     "          (             1                                 )",
     "          (                  c(k)                    s(k) )",
     "          (                         1                     )",
     "          (                              ...              )",
     "          (                                     1         )",
     "          (                 -s(k)                    c(k) )",
     "where R(k) appears in rows and columns k and z.  The rotations are",
     "performed without ever forming P(k) explicitly."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         Specifies whether the plane rotation matrix P is applied to",
       "         A on the left or the right.",
       "         = 'L':  Left, compute A := P*A",
       "         = 'R':  Right, compute A:= A*P**T"],
     "PIVOT"=>
      ["[in]",
       "         PIVOT is CHARACTER*1",
       "         Specifies the plane for which P(k) is a plane rotation",
       "         matrix.",
       "         = 'V':  Variable pivot, the plane (k,k+1)",
       "         = 'T':  Top pivot, the plane (1,k+1)",
       "         = 'B':  Bottom pivot, the plane (k,z)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies whether P is a forward or backward sequence of",
       "         plane rotations.",
       "         = 'F':  Forward, P = P(z-1)*...*P(2)*P(1)",
       "         = 'B':  Backward, P = P(1)*P(2)*...*P(z-1)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  If m <= 1, an immediate",
       "         return is effected."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  If n <= 1, an",
       "         immediate return is effected."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension",
       "                 (M-1) if SIDE = 'L'",
       "                 (N-1) if SIDE = 'R'",
       "         The cosines c(k) of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension",
       "                 (M-1) if SIDE = 'L'",
       "                 (N-1) if SIDE = 'R'",
       "         The sines s(k) of the plane rotations.  The 2-by-2 plane",
       "         rotation part of the matrix P(k), R(k), has the form",
       "         R(k) = (  c(k)  s(k) )",
       "                ( -s(k)  c(k) )."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The M-by-N matrix A.  On exit, A is overwritten by P*A if",
       "         SIDE = 'R' or by A*P**T if SIDE = 'L'."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."]}},
 "zheswapr"=>
  {"summary"=>
    ["ZHESWAPR applies an elementary permutation on the rows and the columns of",
     "a hermitian matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "I1"=>
      ["[in]",
       "         I1 is INTEGER",
       "         Index of the first row to swap"],
     "I2"=>
      ["[in]",
       "         I2 is INTEGER",
       "         Index of the second row to swap"]}},
 "dgeqrt2"=>
  {"summary"=>
    ["DGEQRT2 computes a QR factorization of a real M-by-N matrix A,",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the real M-by-N matrix A.  On exit, the elements on and",
       "         above the diagonal contain the N-by-N upper triangular matrix R; the",
       "         elements below the diagonal are the columns of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zlapmr"=>
  {"summary"=>
    ["ZLAPMR rearranges the rows of the M by N matrix X as specified",
     "by the permutation K(1),K(2),...,K(M) of the integers 1,...,M.",
     "If FORWRD = .TRUE.,  forward permutation:",
     "     X(K(I),*) is moved X(I,*) for I = 1,2,...,M.",
     "If FORWRD = .FALSE., backward permutation:",
     "     X(I,*) is moved to X(K(I),*) for I = 1,2,...,M."],
   "param"=>
    {"FORWRD"=>
      ["[in]",
       "         FORWRD is LOGICAL",
       "         = .TRUE., forward permutation",
       "         = .FALSE., backward permutation"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix X. N >= 0."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,N)",
       "         On entry, the M by N matrix X.",
       "         On exit, X contains the permuted matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X, LDX >= MAX(1,M)."],
     "K"=>
      ["[in,out]",
       "         K is INTEGER array, dimension (M)",
       "         On entry, K contains the permutation vector. K is used as",
       "         internal workspace, but reset to its original value on",
       "         output."]}},
 "dlarre"=>
  {"summary"=>
    ["To find the desired eigenvalues of a given real symmetric",
     "tridiagonal matrix T, DLARRE sets any \"small\" off-diagonal",
     "elements to zero, and for each unreduced block T_i, it finds",
     "(a) a suitable shift at one end of the block's spectrum,",
     "(b) the base representation, T_i - sigma_i I = L_i D_i L_i^T, and",
     "(c) eigenvalues of each L_i D_i L_i^T.",
     "The representations and eigenvalues found are then used by",
     "DSTEMR to compute the eigenvectors of T.",
     "The accuracy varies depending on whether bisection is used to",
     "find a few eigenvalues or the dqds algorithm (subroutine DLASQ2) to",
     "conpute all and then discard any unwanted one.",
     "As an added benefit, DLARRE also outputs the n",
     "Gerschgorin intervals for the matrices L_i D_i L_i^T."],
   "param"=>
    {"RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': (\"All\")   all eigenvalues will be found.",
       "         = 'V': (\"Value\") all eigenvalues in the half-open interval",
       "                          (VL, VU] will be found.",
       "         = 'I': (\"Index\") the IL-th through IU-th eigenvalues (of the",
       "                          entire matrix) will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix. N > 0."],
     "VL"=>
      ["[in,out]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound for the eigenvalues.",
       "         Eigenvalues less than or equal to VL, or greater than VU,",
       "         will not be returned.  VL < VU.",
       "         If RANGE='I' or ='A', DLARRE computes bounds on the desired",
       "         part of the spectrum."],
     "VU"=>
      ["[in,out]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound for the eigenvalues.",
       "         Eigenvalues less than or equal to VL, or greater than VU,",
       "         will not be returned.  VL < VU.",
       "         If RANGE='I' or ='A', DLARRE computes bounds on the desired",
       "         part of the spectrum."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal",
       "         matrix T.",
       "         On exit, the N diagonal elements of the diagonal",
       "         matrices D_i."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the first (N-1) entries contain the subdiagonal",
       "         elements of the tridiagonal matrix T; E(N) need not be set.",
       "         On exit, E contains the subdiagonal elements of the unit",
       "         bidiagonal matrices L_i. The entries E( ISPLIT( I ) ),",
       "         1 <= I <= NSPLIT, contain the base points sigma_i on output."],
     "E2"=>
      ["[in,out]",
       "         E2 is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the first (N-1) entries contain the SQUARES of the",
       "         subdiagonal elements of the tridiagonal matrix T;",
       "         E2(N) need not be set.",
       "         On exit, the entries E2( ISPLIT( I ) ),",
       "         1 <= I <= NSPLIT, have been set to zero"],
     "RTOL1"=>["[in]", "         RTOL1 is DOUBLE PRECISION"],
     "RTOL2"=>
      ["[in]",
       "         RTOL2 is DOUBLE PRECISION",
       "          Parameters for bisection.",
       "          An interval [LEFT,RIGHT] has converged if",
       "          RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )"],
     "SPLTOL"=>
      ["[in]",
       "         SPLTOL is DOUBLE PRECISION",
       "         The threshold for splitting."],
     "NSPLIT"=>
      ["[out]",
       "         NSPLIT is INTEGER",
       "         The number of blocks T splits into. 1 <= NSPLIT <= N."],
     "ISPLIT"=>
      ["[out]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into blocks.",
       "         The first block consists of rows/columns 1 to ISPLIT(1),",
       "         the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),",
       "         etc., and the NSPLIT-th consists of rows/columns",
       "         ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues (of all L_i D_i L_i^T)",
       "         found."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the eigenvalues. The",
       "         eigenvalues of each of the blocks, L_i D_i L_i^T, are",
       "         sorted in ascending order ( DLARRE may use the",
       "         remaining N-M elements as workspace)."],
     "WERR"=>
      ["[out]",
       "         WERR is DOUBLE PRECISION array, dimension (N)",
       "         The error bound on the corresponding eigenvalue in W."],
     "WGAP"=>
      ["[out]",
       "         WGAP is DOUBLE PRECISION array, dimension (N)",
       "         The separation from the right neighbor eigenvalue in W.",
       "         The gap is only with respect to the eigenvalues of the same block",
       "         as each block has its own representation tree.",
       "         Exception: at the right end of a block we store the left gap"],
     "IBLOCK"=>
      ["[out]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         The indices of the blocks (submatrices) associated with the",
       "         corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue",
       "         W(i) belongs to the first block from the top, =2 if W(i)",
       "         belongs to the second block, etc."],
     "INDEXW"=>
      ["[out]",
       "         INDEXW is INTEGER array, dimension (N)",
       "         The indices of the eigenvalues within each block (submatrix);",
       "         for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the",
       "         i-th eigenvalue W(i) is the 10-th eigenvalue in block 2"],
     "GERS"=>
      ["[out]",
       "         GERS is DOUBLE PRECISION array, dimension (2*N)",
       "         The N Gerschgorin intervals (the i-th Gerschgorin interval",
       "         is (GERS(2*i-1), GERS(2*i))."],
     "PIVMIN"=>
      ["[out]",
       "         PIVMIN is DOUBLE PRECISION",
       "         The minimum pivot in the Sturm sequence for T."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (6*N)",
       "         Workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (5*N)",
       "         Workspace."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         > 0:  A problem occurred in DLARRE.",
       "         < 0:  One of the called subroutines signaled an internal problem.",
       "               Needs inspection of the corresponding parameter IINFO",
       "               for further information.",
       "         =-1:  Problem in DLARRD.",
       "         = 2:  No base representation could be found in MAXTRY iterations.",
       "               Increasing MAXTRY and recompilation might be a remedy.",
       "         =-3:  Problem in DLARRB when computing the refined root",
       "               representation for DLASQ2.",
       "         =-4:  Problem in DLARRB when preforming bisection on the",
       "               desired part of the spectrum.",
       "         =-5:  Problem in DLASQ2.",
       "         =-6:  Problem in DLASQ2."]}},
 "zlals0"=>
  {"summary"=>
    ["ZLALS0 applies back the multiplying factors of either the left or the",
     "right singular vector matrix of a diagonal matrix appended by a row",
     "to the right hand side matrix B in solving the least squares problem",
     "using the divide-and-conquer SVD approach.",
     "For the left singular vector matrix, three types of orthogonal",
     "matrices are involved:",
     "(1L) Givens rotations: the number of such rotations is GIVPTR; the",
     "     pairs of columns/rows they were applied to are stored in GIVCOL;",
     "     and the C- and S-values of these rotations are stored in GIVNUM.",
     "(2L) Permutation. The (NL+1)-st row of B is to be moved to the first",
     "     row, and for J=2:N, PERM(J)-th row of B is to be moved to the",
     "     J-th row.",
     "(3L) The left singular vector matrix of the remaining matrix.",
     "For the right singular vector matrix, four types of orthogonal",
     "matrices are involved:",
     "(1R) The right singular vector matrix of the remaining matrix.",
     "(2R) If SQRE = 1, one extra Givens rotation to generate the right",
     "     null space.",
     "(3R) The inverse transformation of (2L).",
     "(4R) The inverse transformation of (1L)."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether singular vectors are to be computed in",
       "        factored form:",
       "        = 0: Left singular vector matrix.",
       "        = 1: Right singular vector matrix."],
     "NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block. NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block. NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has row dimension N = NL + NR + 1,",
       "        and column dimension M = N + SQRE."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B and BX. NRHS must be at least 1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension ( LDB, NRHS )",
       "        On input, B contains the right hand sides of the least",
       "        squares problem in rows 1 through M. On output, B contains",
       "        the solution X in rows 1 through N."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B. LDB must be at least",
       "        max(1,MAX( M, N ) )."],
     "BX"=>
      ["[out]", "         BX is COMPLEX*16 array, dimension ( LDBX, NRHS )"],
     "LDBX"=>
      ["[in]",
       "         LDBX is INTEGER",
       "        The leading dimension of BX."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension ( N )",
       "        The permutations (from deflation and sorting) applied",
       "        to the two blocks."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER",
       "        The number of Givens rotations which took place in this",
       "        subproblem."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )",
       "        Each pair of numbers indicates a pair of rows/columns",
       "        involved in a Givens rotation."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER",
       "        The leading dimension of GIVCOL, must be at least N."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is DOUBLE PRECISION array, dimension ( LDGNUM, 2 )",
       "        Each number indicates the C or S value used in the",
       "        corresponding Givens rotation."],
     "LDGNUM"=>
      ["[in]",
       "         LDGNUM is INTEGER",
       "        The leading dimension of arrays DIFR, POLES and",
       "        GIVNUM, must be at least K."],
     "POLES"=>
      ["[in]",
       "         POLES is DOUBLE PRECISION array, dimension ( LDGNUM, 2 )",
       "        On entry, POLES(1:K, 1) contains the new singular",
       "        values obtained from solving the secular equation, and",
       "        POLES(1:K, 2) is an array containing the poles in the secular",
       "        equation."],
     "DIFL"=>
      ["[in]",
       "         DIFL is DOUBLE PRECISION array, dimension ( K ).",
       "        On entry, DIFL(I) is the distance between I-th updated",
       "        (undeflated) singular value and the I-th (undeflated) old",
       "        singular value."],
     "DIFR"=>
      ["[in]",
       "         DIFR is DOUBLE PRECISION array, dimension ( LDGNUM, 2 ).",
       "        On entry, DIFR(I, 1) contains the distances between I-th",
       "        updated (undeflated) singular value and the I+1-th",
       "        (undeflated) old singular value. And DIFR(I, 2) is the",
       "        normalizing factor for the I-th right singular vector."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension ( K )",
       "        Contain the components of the deflation-adjusted updating row",
       "        vector."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "        Contains the dimension of the non-deflated matrix,",
       "        This is the order of the related secular equation. 1 <= K <=N."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION",
       "        C contains garbage if SQRE =0 and the C-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION",
       "        S contains garbage if SQRE =0 and the S-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension",
       "        ( K*(1+NRHS) + 2*NRHS )"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "sgejsv"=>
  {"summary"=>
    ["SGEJSV computes the singular value decomposition (SVD) of a real M-by-N",
     "matrix [A], where M >= N. The SVD of [A] is written as",
     "             [A] = [U] * [SIGMA] * [V]^t,",
     "where [SIGMA] is an N-by-N (M-by-N) matrix which is zero except for its N",
     "diagonal elements, [U] is an M-by-N (or M-by-M) orthonormal matrix, and",
     "[V] is an N-by-N orthogonal matrix. The diagonal elements of [SIGMA] are",
     "the singular values of [A]. The columns of [U] and [V] are the left and",
     "the right singular vectors of [A], respectively. The matrices [U] and [V]",
     "are computed and stored in the arrays U and V, respectively. The diagonal",
     "of [SIGMA] is computed and stored in the array SVA.",
     "SGEJSV can sometimes compute tiny singular values and their singular vectors much",
     "more accurately than other SVD routines, see below under Further Details."],
   "param"=>
    {"JOBA"=>
      ["[in]",
       "         JOBA is CHARACTER*1",
       "        Specifies the level of accuracy:",
       "      = 'C': This option works well (high relative accuracy) if A = B * D,",
       "             with well-conditioned B and arbitrary diagonal matrix D.",
       "             The accuracy cannot be spoiled by COLUMN scaling. The",
       "             accuracy of the computed output depends on the condition of",
       "             B, and the procedure aims at the best theoretical accuracy.",
       "             The relative error max_{i=1:N}|d sigma_i| / sigma_i is",
       "             bounded by f(M,N)*epsilon* cond(B), independent of D.",
       "             The input matrix is preprocessed with the QRF with column",
       "             pivoting. This initial preprocessing and preconditioning by",
       "             a rank revealing QR factorization is common for all values of",
       "             JOBA. Additional actions are specified as follows:",
       "      = 'E': Computation as with 'C' with an additional estimate of the",
       "             condition number of B. It provides a realistic error bound.",
       "      = 'F': If A = D1 * C * D2 with ill-conditioned diagonal scalings",
       "             D1, D2, and well-conditioned matrix C, this option gives",
       "             higher accuracy than the 'C' option. If the structure of the",
       "             input matrix is not known, and relative accuracy is",
       "             desirable, then this option is advisable. The input matrix A",
       "             is preprocessed with QR factorization with FULL (row and",
       "             column) pivoting.",
       "      = 'G'  Computation as with 'F' with an additional estimate of the",
       "             condition number of B, where A=D*B. If A has heavily weighted",
       "             rows, then using this condition number gives too pessimistic",
       "             error bound.",
       "      = 'A': Small singular values are the noise and the matrix is treated",
       "             as numerically rank deficient. The error in the computed",
       "             singular values is bounded by f(m,n)*epsilon*||A||.",
       "             The computed SVD A = U * S * V^t restores A up to",
       "             f(m,n)*epsilon*||A||.",
       "             This gives the procedure the licence to discard (set to zero)",
       "             all singular values below N*epsilon*||A||.",
       "      = 'R': Similar as in 'A'. Rank revealing property of the initial",
       "             QR factorization is used do reveal (using triangular factor)",
       "             a gap sigma_{r+1} < epsilon * sigma_r in which case the",
       "             numerical RANK is declared to be r. The SVD is computed with",
       "             absolute error bounds, but more accurately than with 'A'."],
     "JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "        Specifies whether to compute the columns of U:",
       "      = 'U': N columns of U are returned in the array U.",
       "      = 'F': full set of M left sing. vectors is returned in the array U.",
       "      = 'W': U may be used as workspace of length M*N. See the description",
       "             of U.",
       "      = 'N': U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "        Specifies whether to compute the matrix V:",
       "      = 'V': N columns of V are returned in the array V; Jacobi rotations",
       "             are not explicitly accumulated.",
       "      = 'J': N columns of V are returned in the array V, but they are",
       "             computed as the product of Jacobi rotations. This option is",
       "             allowed only if JOBU .NE. 'N', i.e. in computing the full SVD.",
       "      = 'W': V may be used as workspace of length N*N. See the description",
       "             of V.",
       "      = 'N': V is not computed."],
     "JOBR"=>
      ["[in]",
       "         JOBR is CHARACTER*1",
       "        Specifies the RANGE for the singular values. Issues the licence to",
       "        set to zero small positive singular values if they are outside",
       "        specified range. If A .NE. 0 is scaled so that the largest singular",
       "        value of c*A is around SQRT(BIG), BIG=SLAMCH('O'), then JOBR issues",
       "        the licence to kill columns of A whose norm in c*A is less than",
       "        SQRT(SFMIN) (for JOBR.EQ.'R'), or less than SMALL=SFMIN/EPSLN,",
       "        where SFMIN=SLAMCH('S'), EPSLN=SLAMCH('E').",
       "      = 'N': Do not kill small columns of c*A. This option assumes that",
       "             BLAS and QR factorizations and triangular solvers are",
       "             implemented to work in that range. If the condition of A",
       "             is greater than BIG, use SGESVJ.",
       "      = 'R': RESTRICTED range for sigma(c*A) is [SQRT(SFMIN), SQRT(BIG)]",
       "             (roughly, as described above). This option is recommended.",
       "                                            ===========================",
       "        For computing the singular values in the FULL range [SFMIN,BIG]",
       "        use SGESVJ."],
     "JOBT"=>
      ["[in]",
       "         JOBT is CHARACTER*1",
       "        If the matrix is square then the procedure may determine to use",
       "        transposed A if A^t seems to be better with respect to convergence.",
       "        If the matrix is not square, JOBT is ignored. This is subject to",
       "        changes in the future.",
       "        The decision is based on two values of entropy over the adjoint",
       "        orbit of A^t * A. See the descriptions of WORK(6) and WORK(7).",
       "      = 'T': transpose if entropy test indicates possibly faster",
       "        convergence of Jacobi process if A^t is taken as input. If A is",
       "        replaced with A^t, then the row pivoting is included automatically.",
       "      = 'N': do not speculate.",
       "        This option can be used to compute only the singular values, or the",
       "        full SVD (U, SIGMA and V). For only one set of singular vectors",
       "        (U or V), the caller should provide both U and V, as one of the",
       "        matrices is used as workspace if the matrix A is transposed.",
       "        The implementer can easily remove this constraint and make the",
       "        code more complicated. See the descriptions of U and V."],
     "JOBP"=>
      ["[in]",
       "         JOBP is CHARACTER*1",
       "        Issues the licence to introduce structured perturbations to drown",
       "        denormalized numbers. This licence should be active if the",
       "        denormals are poorly implemented, causing slow computation,",
       "        especially in cases of fast convergence (!). For details see [1,2].",
       "        For the sake of simplicity, this perturbations are included only",
       "        when the full SVD or only the singular values are requested. The",
       "        implementer/user can easily add the perturbation for the cases of",
       "        computing one set of singular vectors.",
       "      = 'P': introduce perturbation",
       "      = 'N': do not perturb"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "        The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The number of columns of the input matrix A. M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "SVA"=>
      ["[out]",
       "         SVA is REAL array, dimension (N)",
       "         On exit,",
       "         - For WORK(1)/WORK(2) = ONE: The singular values of A. During the",
       "           computation SVA contains Euclidean column norms of the",
       "           iterated matrices in the array A.",
       "         - For WORK(1) .NE. WORK(2): The singular values of A are",
       "           (WORK(1)/WORK(2)) * SVA(1:N). This factored form is used if",
       "           sigma_max(A) overflows or if small singular values have been",
       "           saved from underflow by scaling the input matrix A.",
       "         - If JOBR='R' then some of the singular values may be returned",
       "           as exact zeros obtained by \"set to zero\" because they are",
       "           below the numerical rank threshold or are denormalized numbers."],
     "U"=>
      ["[out]",
       "         U is REAL array, dimension ( LDU, N )",
       "         If JOBU = 'U', then U contains on exit the M-by-N matrix of",
       "                        the left singular vectors.",
       "         If JOBU = 'F', then U contains on exit the M-by-M matrix of",
       "                        the left singular vectors, including an ONB",
       "                        of the orthogonal complement of the Range(A).",
       "         If JOBU = 'W'  .AND. (JOBV.EQ.'V' .AND. JOBT.EQ.'T' .AND. M.EQ.N),",
       "                        then U is used as workspace if the procedure",
       "                        replaces A with A^t. In that case, [V] is computed",
       "                        in U as left singular vectors of A^t and then",
       "                        copied back to the V array. This 'W' option is just",
       "                        a reminder to the caller that in this case U is",
       "                        reserved as workspace of length N*N.",
       "         If JOBU = 'N'  U is not referenced, unless JOBT='T'."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U,  LDU >= 1.",
       "         IF  JOBU = 'U' or 'F' or 'W',  then LDU >= M."],
     "V"=>
      ["[out]",
       "         V is REAL array, dimension ( LDV, N )",
       "         If JOBV = 'V', 'J' then V contains on exit the N-by-N matrix of",
       "                        the right singular vectors;",
       "         If JOBV = 'W', AND (JOBU.EQ.'U' AND JOBT.EQ.'T' AND M.EQ.N),",
       "                        then V is used as workspace if the pprocedure",
       "                        replaces A with A^t. In that case, [U] is computed",
       "                        in V as right singular vectors of A^t and then",
       "                        copied back to the U array. This 'W' option is just",
       "                        a reminder to the caller that in this case V is",
       "                        reserved as workspace of length N*N.",
       "         If JOBV = 'N'  V is not referenced, unless JOBT='T'."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V' or 'J' or 'W', then LDV >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension at least LWORK.",
       "         On exit,",
       "         WORK(1) = SCALE = WORK(2) / WORK(1) is the scaling factor such",
       "                   that SCALE*SVA(1:N) are the computed singular values",
       "                   of A. (See the description of SVA().)",
       "         WORK(2) = See the description of WORK(1).",
       "         WORK(3) = SCONDA is an estimate for the condition number of",
       "                   column equilibrated A. (If JOBA .EQ. 'E' or 'G')",
       "                   SCONDA is an estimate of SQRT(||(R^t * R)^(-1)||_1).",
       "                   It is computed using SPOCON. It holds",
       "                   N^(-1/4) * SCONDA <= ||R^(-1)||_2 <= N^(1/4) * SCONDA",
       "                   where R is the triangular factor from the QRF of A.",
       "                   However, if R is truncated and the numerical rank is",
       "                   determined to be strictly smaller than N, SCONDA is",
       "                   returned as -1, thus indicating that the smallest",
       "                   singular values might be lost.",
       "         If full SVD is needed, the following two condition numbers are",
       "         useful for the analysis of the algorithm. They are provied for",
       "         a developer/implementer who is familiar with the details of",
       "         the method.",
       "         WORK(4) = an estimate of the scaled condition number of the",
       "                   triangular factor in the first QR factorization.",
       "         WORK(5) = an estimate of the scaled condition number of the",
       "                   triangular factor in the second QR factorization.",
       "         The following two parameters are computed if JOBT .EQ. 'T'.",
       "         They are provided for a developer/implementer who is familiar",
       "         with the details of the method.",
       "         WORK(6) = the entropy of A^t*A :: this is the Shannon entropy",
       "                   of diag(A^t*A) / Trace(A^t*A) taken as point in the",
       "                   probability simplex.",
       "         WORK(7) = the entropy of A*A^t."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         Length of WORK to confirm proper allocation of work space.",
       "         LWORK depends on the job:",
       "         If only SIGMA is needed ( JOBU.EQ.'N', JOBV.EQ.'N' ) and",
       "           -> .. no scaled condition estimate required (JOBE.EQ.'N'):",
       "              LWORK >= max(2*M+N,4*N+1,7). This is the minimal requirement.",
       "              ->> For optimal performance (blocked code) the optimal value",
       "              is LWORK >= max(2*M+N,3*N+(N+1)*NB,7). Here NB is the optimal",
       "              block size for DGEQP3 and DGEQRF.",
       "              In general, optimal LWORK is computed as",
       "              LWORK >= max(2*M+N,N+LWORK(DGEQP3),N+LWORK(DGEQRF), 7).",
       "           -> .. an estimate of the scaled condition number of A is",
       "              required (JOBA='E', 'G'). In this case, LWORK is the maximum",
       "              of the above and N*N+4*N, i.e. LWORK >= max(2*M+N,N*N+4*N,7).",
       "              ->> For optimal performance (blocked code) the optimal value",
       "              is LWORK >= max(2*M+N,3*N+(N+1)*NB, N*N+4*N, 7).",
       "              In general, the optimal length LWORK is computed as",
       "              LWORK >= max(2*M+N,N+LWORK(DGEQP3),N+LWORK(DGEQRF),",
       "                                                    N+N*N+LWORK(DPOCON),7).",
       "         If SIGMA and the right singular vectors are needed (JOBV.EQ.'V'),",
       "           -> the minimal requirement is LWORK >= max(2*M+N,4*N+1,7).",
       "           -> For optimal performance, LWORK >= max(2*M+N,3*N+(N+1)*NB,7),",
       "              where NB is the optimal block size for DGEQP3, DGEQRF, DGELQ,",
       "              DORMLQ. In general, the optimal length LWORK is computed as",
       "              LWORK >= max(2*M+N,N+LWORK(DGEQP3), N+LWORK(DPOCON),",
       "                      N+LWORK(DGELQ), 2*N+LWORK(DGEQRF), N+LWORK(DORMLQ)).",
       "         If SIGMA and the left singular vectors are needed",
       "           -> the minimal requirement is LWORK >= max(2*M+N,4*N+1,7).",
       "           -> For optimal performance:",
       "              if JOBU.EQ.'U' :: LWORK >= max(2*M+N,3*N+(N+1)*NB,7),",
       "              if JOBU.EQ.'F' :: LWORK >= max(2*M+N,3*N+(N+1)*NB,N+M*NB,7),",
       "              where NB is the optimal block size for DGEQP3, DGEQRF, DORMQR.",
       "              In general, the optimal length LWORK is computed as",
       "              LWORK >= max(2*M+N,N+LWORK(DGEQP3),N+LWORK(DPOCON),",
       "                       2*N+LWORK(DGEQRF), N+LWORK(DORMQR)).",
       "              Here LWORK(DORMQR) equals N*NB (for JOBU.EQ.'U') or",
       "              M*NB (for JOBU.EQ.'F').",
       "         If the full SVD is needed: (JOBU.EQ.'U' or JOBU.EQ.'F') and",
       "           -> if JOBV.EQ.'V'",
       "              the minimal requirement is LWORK >= max(2*M+N,6*N+2*N*N).",
       "           -> if JOBV.EQ.'J' the minimal requirement is",
       "              LWORK >= max(2*M+N, 4*N+N*N,2*N+N*N+6).",
       "           -> For optimal performance, LWORK should be additionally",
       "              larger than N+M*NB, where NB is the optimal block size",
       "              for DORMQR."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension M+3*N.",
       "         On exit,",
       "         IWORK(1) = the numerical rank determined after the initial",
       "                    QR factorization with pivoting. See the descriptions",
       "                    of JOBA and JOBR.",
       "         IWORK(2) = the number of the computed nonzero singular values",
       "         IWORK(3) = if nonzero, a warning message:",
       "                    If IWORK(3).EQ.1 then some of the column norms of A",
       "                    were denormalized floats. The requested high accuracy",
       "                    is not warranted by the data."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          < 0  : if INFO = -i, then the i-th argument had an illegal value.",
       "          = 0 :  successful exit;",
       "          > 0 :  SGEJSV  did not converge in the maximal allowed number",
       "                 of sweeps. The computed values may be inaccurate."]}},
 "cggevx"=>
  {"summary"=>
    ["CGGEVX computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B) the generalized eigenvalues, and optionally, the left and/or",
     "right generalized eigenvectors.",
     "Optionally, it also computes a balancing transformation to improve",
     "the conditioning of the eigenvalues and eigenvectors (ILO, IHI,",
     "LSCALE, RSCALE, ABNRM, and BBNRM), reciprocal condition numbers for",
     "the eigenvalues (RCONDE), and reciprocal condition numbers for the",
     "right eigenvectors (RCONDV).",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right eigenvector v(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 A * v(j) = lambda(j) * B * v(j) .",
     "The left eigenvector u(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 u(j)**H * A  = lambda(j) * u(j)**H * B.",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"BALANC"=>
      ["[in]",
       "         BALANC is CHARACTER*1",
       "         Specifies the balance option to be performed:",
       "         = 'N':  do not diagonally scale or permute;",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale.",
       "         Computed reciprocal condition numbers will be for the",
       "         matrices after permuting and/or balancing. Permuting does",
       "         not change condition numbers (in exact arithmetic), but",
       "         balancing does."],
     "JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': none are computed;",
       "         = 'E': computed for eigenvalues only;",
       "         = 'V': computed for eigenvectors only;",
       "         = 'B': computed for eigenvalues and eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten. If JOBVL='V' or JOBVR='V'",
       "         or both, then A contains the first part of the complex Schur",
       "         form of the \"balanced\" versions of the input A and B."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten. If JOBVL='V' or JOBVR='V'",
       "         or both, then B contains the second part of the complex",
       "         Schur form of the \"balanced\" versions of the input A and B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX array, dimension (N)",
       "         On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the generalized",
       "         eigenvalues.",
       "         Note: the quotient ALPHA(j)/BETA(j) ) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio ALPHA/BETA.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is COMPLEX array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left generalized eigenvectors u(j) are",
       "         stored one after another in the columns of VL, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector will be scaled so the largest component",
       "         will have abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is COMPLEX array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right generalized eigenvectors v(j) are",
       "         stored one after another in the columns of VR, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector will be scaled so the largest component",
       "         will have abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are integer values such that on exit",
       "         A(i,j) = 0 and B(i,j) = 0 if i > j and",
       "         j = 1,...,ILO-1 or i = IHI+1,...,N.",
       "         If BALANC = 'N' or 'S', ILO = 1 and IHI = N."],
     "LSCALE"=>
      ["[out]",
       "         LSCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the left side of A and B.  If PL(j) is the index of the",
       "         row interchanged with row j, and DL(j) is the scaling",
       "         factor applied to row j, then",
       "           LSCALE(j) = PL(j)  for j = 1,...,ILO-1",
       "                     = DL(j)  for j = ILO,...,IHI",
       "                     = PL(j)  for j = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "RSCALE"=>
      ["[out]",
       "         RSCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the right side of A and B.  If PR(j) is the index of the",
       "         column interchanged with column j, and DR(j) is the scaling",
       "         factor applied to column j, then",
       "           RSCALE(j) = PR(j)  for j = 1,...,ILO-1",
       "                     = DR(j)  for j = ILO,...,IHI",
       "                     = PR(j)  for j = IHI+1,...,N",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "ABNRM"=>
      ["[out]",
       "         ABNRM is REAL",
       "         The one-norm of the balanced matrix A."],
     "BBNRM"=>
      ["[out]",
       "         BBNRM is REAL",
       "         The one-norm of the balanced matrix B."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is REAL array, dimension (N)",
       "         If SENSE = 'E' or 'B', the reciprocal condition numbers of",
       "         the eigenvalues, stored in consecutive elements of the array.",
       "         If SENSE = 'N' or 'V', RCONDE is not referenced."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is REAL array, dimension (N)",
       "         If SENSE = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the eigenvectors, stored in consecutive elements",
       "         of the array. If the eigenvalues cannot be reordered to",
       "         compute RCONDV(j), RCONDV(j) is set to 0; this can only occur",
       "         when the true value would be very small anyway.",
       "         If SENSE = 'N' or 'E', RCONDV is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,2*N).",
       "         If SENSE = 'E', LWORK >= max(1,4*N).",
       "         If SENSE = 'V' or 'B', LWORK >= max(1,2*N*N+2*N).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (lrwork)",
       "         lrwork must be at least max(1,6*N) if BALANC = 'S' or 'B',",
       "         and at least max(1,2*N) otherwise.",
       "         Real workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N+2)",
       "         If SENSE = 'E', IWORK is not referenced."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         If SENSE = 'N', BWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHA(j) and BETA(j) should be correct",
       "               for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in CHGEQZ.",
       "               =N+2: error return from CTGEVC."]}},
 "slanhs"=>
  {"summary"=>
    ["SLANHS  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "Hessenberg matrix A.",
     "   SLANHS = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANHS as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, SLANHS is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The n by n upper Hessenberg matrix A; the part of A below the",
       "         first sub-diagonal is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "dgeqrt3"=>
  {"summary"=>
    ["DGEQRT3 recursively computes a QR factorization of a real M-by-N",
     "matrix A, using the compact WY representation of Q.",
     "Based on the algorithm of Elmroth and Gustavson,",
     "IBM J. Res. Develop. Vol 44 No. 4 July 2000."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the real M-by-N matrix A.  On exit, the elements on and",
       "         above the diagonal contain the N-by-N upper triangular matrix R; the",
       "         elements below the diagonal are the columns of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "sla_geamv"=>
  {"summary"=>
    ["SLA_GEAMV  performs one of the matrix-vector operations",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "   or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "m by n matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is INTEGER",
       "          On entry, TRANS specifies the operation to be performed as",
       "          follows:",
       "            BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)",
       "            BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "            BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of the matrix A.",
       "          M must be at least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is REAL array of DIMENSION ( LDA, n )",
       "          Before entry, the leading m by n part of the array A must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, m ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is REAL array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL",
       "          Array of DIMENSION at least",
       "          ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit.",
       " Level 2 Blas routine."]}},
 "dgesvdx"=>
  {"summary"=>
    [" DGESVDX computes the singular value decomposition (SVD) of a real",
     " M-by-N matrix A, optionally computing the left and/or right singular",
     " vectors. The SVD is written",
     "     A = U * SIGMA * transpose(V)",
     " where SIGMA is an M-by-N matrix which is zero except for its",
     " min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and",
     " V is an N-by-N orthogonal matrix.  The diagonal elements of SIGMA",
     " are the singular values of A; they are real and non-negative, and",
     " are returned in descending order.  The first min(m,n) columns of",
     " U and V are the left and right singular vectors of A.",
     " DGESVDX uses an eigenvalue problem for obtaining the SVD, which",
     " allows for the computation of a subset of singular values and",
     " vectors. See DBDSVDX for details.",
     " Note that the routine returns V**T, not V."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'V':  the first min(m,n) columns of U (the left singular",
       "                 vectors) or as specified by RANGE are returned in",
       "                 the array U;",
       "         = 'N':  no columns of U (no left singular vectors) are",
       "                 computed."],
     "JOBVT"=>
      ["[in]",
       "         JOBVT is CHARACTER*1",
       "          Specifies options for computing all or part of the matrix",
       "          V**T:",
       "          = 'V':  the first min(m,n) rows of V**T (the right singular",
       "                  vectors) or as specified by RANGE are returned in",
       "                  the array VT;",
       "          = 'N':  no rows of V**T (no right singular vectors) are",
       "                  computed."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all singular values will be found.",
       "         = 'V': all singular values in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th singular values will be found."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the contents of A are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for singular values. VU > VL.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest singular value to be returned.",
       "         1 <= IL <= IU <= min(M,N), if min(M,N) > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "NS"=>
      ["[out]",
       "         NS is INTEGER",
       "         The total number of singular values found,",
       "         0 <= NS <= min(M,N).",
       "         If RANGE = 'A', NS = min(M,N); if RANGE = 'I', NS = IU-IL+1."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is DOUBLE PRECISION array, dimension (LDU,UCOL)",
       "         If JOBU = 'V', U contains columns of U (the left singular",
       "         vectors, stored columnwise) as specified by RANGE; if",
       "         JOBU = 'N', U is not referenced.",
       "         Note: The user must ensure that UCOL >= NS; if RANGE = 'V',",
       "         the exact value of NS is not known in advance and an upper",
       "         bound must be used."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1; if",
       "         JOBU = 'V', LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is DOUBLE PRECISION array, dimension (LDVT,N)",
       "         If JOBVT = 'V', VT contains the rows of V**T (the right singular",
       "         vectors, stored rowwise) as specified by RANGE; if JOBVT = 'N',",
       "         VT is not referenced.",
       "         Note: The user must ensure that LDVT >= NS; if RANGE = 'V',",
       "         the exact value of NS is not known in advance and an upper",
       "         bound must be used."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1; if",
       "         JOBVT = 'V', LDVT >= NS (see above)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK;"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= MAX(1,MIN(M,N)*(MIN(M,N)+4)) for the paths (see",
       "         comments inside the code):",
       "            - PATH 1  (M much larger than N)",
       "            - PATH 1t (N much larger than M)",
       "         LWORK >= MAX(1,MIN(M,N)*2+MAX(M,N)) for the other paths.",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (12*MIN(M,N))",
       "         If INFO = 0, the first NS elements of IWORK are zero. If INFO > 0,",
       "         then IWORK contains the indices of the eigenvectors that failed",
       "         to converge in DBDSVDX/DSTEVX."],
     "INFO"=>
      ["[out]",
       "    INFO is INTEGER",
       "          = 0:  successful exit",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value",
       "          > 0:  if INFO = i, then i eigenvectors failed to converge",
       "                in DBDSVDX/DSTEVX.",
       "                if INFO = N*2 + 1, an internal error occurred in",
       "                DBDSVDX"]}},
 "slanst"=>
  {"summary"=>
    ["SLANST  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "real symmetric tridiagonal matrix A.",
     "   SLANST = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANST as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, SLANST is",
       "         set to zero."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of A."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N-1)",
       "         The (n-1) sub-diagonal or super-diagonal elements of A."]}},
 "zgelsd"=>
  {"summary"=>
    ["ZGELSD computes the minimum-norm solution to a real linear least",
     "squares problem:",
     "    minimize 2-norm(| b - A*x |)",
     "using the singular value decomposition (SVD) of A. A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X.",
     "The problem is solved in three steps:",
     "(1) Reduce the coefficient matrix A to bidiagonal form with",
     "    Householder transformations, reducing the original problem",
     "    into a \"bidiagonal least squares problem\" (BLS)",
     "(2) Solve the BLS using a divide and conquer approach.",
     "(3) Apply back all the Householder transformations to solve",
     "    the original least squares problem.",
     "The effective rank of A is determined by treating as zero those",
     "singular values which are less than RCOND times the largest singular",
     "value.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A has been destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, B is overwritten by the N-by-NRHS solution matrix X.",
       "         If m >= n and RANK = n, the residual sum-of-squares for",
       "         the solution in the i-th column is given by the sum of",
       "         squares of the modulus of elements n+1:m in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M,N)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The singular values of A in decreasing order.",
       "         The condition number of A in the 2-norm = S(1)/S(min(m,n))."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "         RCOND is used to determine the effective rank of A.",
       "         Singular values S(i) <= RCOND*S(1) are treated as zero.",
       "         If RCOND < 0, machine precision is used instead."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the number of singular values",
       "         which are greater than RCOND*S(1)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK must be at least 1.",
       "         The exact minimum amount of workspace needed depends on M,",
       "         N and NRHS. As long as LWORK is at least",
       "             2*N + N*NRHS",
       "         if M is greater than or equal to N or",
       "             2*M + M*NRHS",
       "         if M is less than N, the code will execute correctly.",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the array WORK and the",
       "         minimum sizes of the arrays RWORK and IWORK, and returns",
       "         these values as the first entries of the WORK, RWORK and",
       "         IWORK arrays, and no error message related to LWORK is issued",
       "         by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))",
       "         LRWORK >=",
       "            10*N + 2*N*SMLSIZ + 8*N*NLVL + 3*SMLSIZ*NRHS +",
       "            MAX( (SMLSIZ+1)**2, N*(1+NRHS) + 2*NRHS )",
       "         if M is greater than or equal to N or",
       "            10*M + 2*M*SMLSIZ + 8*M*NLVL + 3*SMLSIZ*NRHS +",
       "            MAX( (SMLSIZ+1)**2, N*(1+NRHS) + 2*NRHS )",
       "         if M is less than N, the code will execute correctly.",
       "         SMLSIZ is returned by ILAENV and is equal to the maximum",
       "         size of the subproblems at the bottom of the computation",
       "         tree (usually about 25), and",
       "            NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 )",
       "         On exit, if INFO = 0, RWORK(1) returns the minimum LRWORK."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         LIWORK >= max(1, 3*MINMN*NLVL + 11*MINMN),",
       "         where MINMN = MIN( M,N ).",
       "         On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  the algorithm for computing the SVD failed to converge;",
       "               if INFO = i, i off-diagonal elements of an intermediate",
       "               bidiagonal form did not converge to zero."]}},
 "cgesvj"=>
  {"summary"=>
    ["CGESVJ computes the singular value decomposition (SVD) of a complex",
     "M-by-N matrix A, where M >= N. The SVD of A is written as",
     "                                   [++]   [xx]   [x0]   [xx]",
     "             A = U * SIGMA * V^*,  [++] = [xx] * [ox] * [xx]",
     "                                   [++]   [xx]",
     "where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal",
     "matrix, and V is an N-by-N unitary matrix. The diagonal elements",
     "of SIGMA are the singular values of A. The columns of U and V are the",
     "left and the right singular vectors of A, respectively."],
   "param"=>
    {"JOBA"=>
      ["[in]",
       "         JOBA is CHARACTER* 1",
       "         Specifies the structure of A.",
       "         = 'L': The input matrix A is lower triangular;",
       "         = 'U': The input matrix A is upper triangular;",
       "         = 'G': The input matrix A is general M-by-N matrix, M >= N."],
     "JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies whether to compute the left singular vectors",
       "         (columns of U):",
       "         = 'U' or 'F': The left singular vectors corresponding to the nonzero",
       "                singular values are computed and returned in the leading",
       "                columns of A. See more details in the description of A.",
       "                The default numerical orthogonality threshold is set to",
       "                approximately TOL=CTOL*EPS, CTOL=SQRT(M), EPS=SLAMCH('E').",
       "         = 'C': Analogous to JOBU='U', except that user can control the",
       "                level of numerical orthogonality of the computed left",
       "                singular vectors. TOL can be set to TOL = CTOL*EPS, where",
       "                CTOL is given on input in the array WORK.",
       "                No CTOL smaller than ONE is allowed. CTOL greater",
       "                than 1 / EPS is meaningless. The option 'C'",
       "                can be used if M*EPS is satisfactory orthogonality",
       "                of the computed left singular vectors, so CTOL=M could",
       "                save few sweeps of Jacobi rotations.",
       "                See the descriptions of A and WORK(1).",
       "         = 'N': The matrix U is not computed. However, see the",
       "                description of A."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether to compute the right singular vectors, that",
       "         is, the matrix V:",
       "         = 'V' or 'J': the matrix V is computed and returned in the array V",
       "         = 'A' : the Jacobi rotations are applied to the MV-by-N",
       "                 array V. In other words, the right singular vector",
       "                 matrix V is not computed explicitly; instead it is",
       "                 applied to an MV-by-N matrix initially stored in the",
       "                 first MV rows of V.",
       "         = 'N' : the matrix V is not computed and the array V is not",
       "                 referenced"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A. 1/SLAMCH('E') > M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         If JOBU .EQ. 'U' .OR. JOBU .EQ. 'C':",
       "                If INFO .EQ. 0 :",
       "                RANKA orthonormal columns of U are returned in the",
       "                leading RANKA columns of the array A. Here RANKA <= N",
       "                is the number of computed singular values of A that are",
       "                above the underflow threshold SLAMCH('S'). The singular",
       "                vectors corresponding to underflowed or zero singular",
       "                values are not computed. The value of RANKA is returned",
       "                in the array RWORK as RANKA=NINT(RWORK(2)). Also see the",
       "                descriptions of SVA and RWORK. The computed columns of U",
       "                are mutually numerically orthogonal up to approximately",
       "                TOL=SQRT(M)*EPS (default); or TOL=CTOL*EPS (JOBU.EQ.'C'),",
       "                see the description of JOBU.",
       "                If INFO .GT. 0,",
       "                the procedure CGESVJ did not converge in the given number",
       "                of iterations (sweeps). In that case, the computed",
       "                columns of U may not be orthogonal up to TOL. The output",
       "                U (stored in A), SIGMA (given by the computed singular",
       "                values in SVA(1:N)) and V is still a decomposition of the",
       "                input matrix A in the sense that the residual",
       "                || A - SCALE * U * SIGMA * V^* ||_2 / ||A||_2 is small.",
       "         If JOBU .EQ. 'N':",
       "                If INFO .EQ. 0 :",
       "                Note that the left singular vectors are 'for free' in the",
       "                one-sided Jacobi SVD algorithm. However, if only the",
       "                singular values are needed, the level of numerical",
       "                orthogonality of U is not an issue and iterations are",
       "                stopped when the columns of the iterated matrix are",
       "                numerically orthogonal up to approximately M*EPS. Thus,",
       "                on exit, A contains the columns of U scaled with the",
       "                corresponding singular values.",
       "                If INFO .GT. 0 :",
       "                the procedure CGESVJ did not converge in the given number",
       "                of iterations (sweeps)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "SVA"=>
      ["[out]",
       "         SVA is REAL array, dimension (N)",
       "         On exit,",
       "         If INFO .EQ. 0 :",
       "         depending on the value SCALE = RWORK(1), we have:",
       "                If SCALE .EQ. ONE:",
       "                SVA(1:N) contains the computed singular values of A.",
       "                During the computation SVA contains the Euclidean column",
       "                norms of the iterated matrices in the array A.",
       "                If SCALE .NE. ONE:",
       "                The singular values of A are SCALE*SVA(1:N), and this",
       "                factored representation is due to the fact that some of the",
       "                singular values of A might underflow or overflow.",
       "         If INFO .GT. 0 :",
       "         the procedure CGESVJ did not converge in the given number of",
       "         iterations (sweeps) and SCALE*SVA(1:N) may not be accurate."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then the product of Jacobi rotations in CGESVJ",
       "         is applied to the first MV rows of V. See the description of JOBV."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX array, dimension (LDV,N)",
       "         If JOBV = 'V', then V contains on exit the N-by-N matrix of",
       "                        the right singular vectors;",
       "         If JOBV = 'A', then V contains the product of the computed right",
       "                        singular vector matrix and the initial matrix in",
       "                        the array V.",
       "         If JOBV = 'N', then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V, LDV .GE. 1.",
       "         If JOBV .EQ. 'V', then LDV .GE. max(1,N).",
       "         If JOBV .EQ. 'A', then LDV .GE. max(1,MV) ."],
     "CWORK"=>
      ["[in,out]",
       "         CWORK is COMPLEX array, dimension max(1,LWORK).",
       "         Used as workspace.",
       "         If on entry LWORK .EQ. -1, then a workspace query is assumed and",
       "         no computation is done; CWORK(1) is set to the minial (and optimal)",
       "         length of CWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER.",
       "         Length of CWORK, LWORK >= M+N."],
     "RWORK"=>
      ["[in,out]",
       "         RWORK is REAL array, dimension max(6,LRWORK).",
       "         On entry,",
       "         If JOBU .EQ. 'C' :",
       "         RWORK(1) = CTOL, where CTOL defines the threshold for convergence.",
       "                   The process stops if all columns of A are mutually",
       "                   orthogonal up to CTOL*EPS, EPS=SLAMCH('E').",
       "                   It is required that CTOL >= ONE, i.e. it is not",
       "                   allowed to force the routine to obtain orthogonality",
       "                   below EPSILON.",
       "         On exit,",
       "         RWORK(1) = SCALE is the scaling factor such that SCALE*SVA(1:N)",
       "                   are the computed singular values of A.",
       "                   (See description of SVA().)",
       "         RWORK(2) = NINT(RWORK(2)) is the number of the computed nonzero",
       "                   singular values.",
       "         RWORK(3) = NINT(RWORK(3)) is the number of the computed singular",
       "                   values that are larger than the underflow threshold.",
       "         RWORK(4) = NINT(RWORK(4)) is the number of sweeps of Jacobi",
       "                   rotations needed for numerical convergence.",
       "         RWORK(5) = max_{i.NE.j} |COS(A(:,i),A(:,j))| in the last sweep.",
       "                   This is useful information in cases when CGESVJ did",
       "                   not converge, as it can be used to estimate whether",
       "                   the output is stil useful and for post festum analysis.",
       "         RWORK(6) = the largest absolute value over all sines of the",
       "                   Jacobi rotation angles in the last sweep. It can be",
       "                   useful for a post festum analysis.",
       "        If on entry LRWORK .EQ. -1, then a workspace query is assumed and",
       "        no computation is done; RWORK(1) is set to the minial (and optimal)",
       "        length of RWORK."],
     "LRWORK"=>
      ["[in]",
       "        LRWORK is INTEGER",
       "        Length of RWORK, LRWORK >= MAX(6,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value",
       "         > 0 : CGESVJ did not converge in the maximal allowed number",
       "               (NSWEEP=30) of sweeps. The output may still be useful.",
       "               See the description of RWORK."]}},
 "dorbdb6"=>
  {"summary"=>[],
   "param"=>
    {"M1"=>
      ["[in]",
       "         M1 is INTEGER",
       "          The dimension of X1 and the number of rows in Q1. 0 <= M1."],
     "M2"=>
      ["[in]",
       "         M2 is INTEGER",
       "          The dimension of X2 and the number of rows in Q2. 0 <= M2."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The number of columns in Q1 and Q2. 0 <= N."],
     "X1"=>
      ["[in,out]",
       "         X1 is DOUBLE PRECISION array, dimension (M1)",
       "          On entry, the top part of the vector to be orthogonalized.",
       "          On exit, the top part of the projected vector."],
     "INCX1"=>
      ["[in]",
       "         INCX1 is INTEGER",
       "          Increment for entries of X1."],
     "X2"=>
      ["[in,out]",
       "         X2 is DOUBLE PRECISION array, dimension (M2)",
       "          On entry, the bottom part of the vector to be",
       "          orthogonalized. On exit, the bottom part of the projected",
       "          vector."],
     "INCX2"=>
      ["[in]",
       "         INCX2 is INTEGER",
       "          Increment for entries of X2."],
     "Q1"=>
      ["[in]",
       "         Q1 is DOUBLE PRECISION array, dimension (LDQ1, N)",
       "          The top part of the orthonormal basis matrix."],
     "LDQ1"=>
      ["[in]",
       "         LDQ1 is INTEGER",
       "          The leading dimension of Q1. LDQ1 >= M1."],
     "Q2"=>
      ["[in]",
       "         Q2 is DOUBLE PRECISION array, dimension (LDQ2, N)",
       "          The bottom part of the orthonormal basis matrix."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "          The leading dimension of Q2. LDQ2 >= M2."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zgbtf2"=>
  {"summary"=>
    ["ZGBTF2 computes an LU factorization of a complex m-by-n band matrix",
     "A using partial pivoting with row interchanges.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(kl+ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = +i, U(i,i) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "zunbdb3"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M. M-P <= min(P,Q,M-Q)."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX*16 array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX*16 array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is COMPLEX*16 array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is COMPLEX*16 array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is COMPLEX*16 array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slacpy"=>
  {"summary"=>
    ["SLACPY copies all or part of a two-dimensional matrix A to another",
     "matrix B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the part of the matrix A to be copied to B.",
       "         = 'U':      Upper triangular part",
       "         = 'L':      Lower triangular part",
       "         Otherwise:  All of the matrix A"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The m by n matrix A.  If UPLO = 'U', only the upper triangle",
       "         or trapezoid is accessed; if UPLO = 'L', only the lower",
       "         triangle or trapezoid is accessed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On exit, B = A in the locations specified by UPLO."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."]}},
 "sspevd"=>
  {"summary"=>
    ["SSPEVD computes all the eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A in packed storage. If eigenvectors are",
     "desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the required LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be at least 2*N.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least",
       "                                                1 + 6*N + N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the required sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the required LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "cgetc2"=>
  {"summary"=>
    ["CGETC2 computes an LU factorization, using complete pivoting, of the",
     "n-by-n matrix A. The factorization has the form A = P * L * U * Q,",
     "where P and Q are permutation matrices, L is lower triangular with",
     "unit diagonal elements and U is upper triangular.",
     "This is a level 1 BLAS version of the algorithm."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the n-by-n matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U*Q; the unit diagonal elements of L are not stored.",
       "         If U(k, k) appears to be less than SMIN, U(k, k) is given the",
       "         value of SMIN, giving a nonsingular perturbed system."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1, N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[out]",
       "         JPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0: successful exit",
       "          > 0: if INFO = k, U(k, k) is likely to produce overflow if",
       "               one tries to solve for x in Ax = b. So U is perturbed",
       "               to avoid the overflow."]}},
 "zladiv"=>
  {"summary"=>
    ["ZLADIV := X / Y, where X and Y are complex.  The computation of X / Y",
     "will not overflow on an intermediary step unless the results",
     "overflows."],
   "param"=>
    {"X"=>["[in]", "         X is COMPLEX*16"],
     "Y"=>
      ["[in]",
       "         Y is COMPLEX*16",
       "         The complex scalars X and Y."]}},
 "ctrrfs"=>
  {"summary"=>
    ["CTRRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular",
     "coefficient matrix.",
     "The solution matrix X must be computed by CTRTRS or some other",
     "means before entering this routine.  CTRRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgesvd"=>
  {"summary"=>
    ["DGESVD computes the singular value decomposition (SVD) of a real",
     "M-by-N matrix A, optionally computing the left and/or right singular",
     "vectors. The SVD is written",
     "     A = U * SIGMA * transpose(V)",
     "where SIGMA is an M-by-N matrix which is zero except for its",
     "min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and",
     "V is an N-by-N orthogonal matrix.  The diagonal elements of SIGMA",
     "are the singular values of A; they are real and non-negative, and",
     "are returned in descending order.  The first min(m,n) columns of",
     "U and V are the left and right singular vectors of A.",
     "Note that the routine returns V**T, not V."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'A':  all M columns of U are returned in array U:",
       "         = 'S':  the first min(m,n) columns of U (the left singular",
       "                 vectors) are returned in the array U;",
       "         = 'O':  the first min(m,n) columns of U (the left singular",
       "                 vectors) are overwritten on the array A;",
       "         = 'N':  no columns of U (no left singular vectors) are",
       "                 computed."],
     "JOBVT"=>
      ["[in]",
       "         JOBVT is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix",
       "         V**T:",
       "         = 'A':  all N rows of V**T are returned in the array VT;",
       "         = 'S':  the first min(m,n) rows of V**T (the right singular",
       "                 vectors) are returned in the array VT;",
       "         = 'O':  the first min(m,n) rows of V**T (the right singular",
       "                 vectors) are overwritten on the array A;",
       "         = 'N':  no rows of V**T (no right singular vectors) are",
       "                 computed.",
       "         JOBVT and JOBU cannot both be 'O'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if JOBU = 'O',  A is overwritten with the first min(m,n)",
       "                         columns of U (the left singular vectors,",
       "                         stored columnwise);",
       "         if JOBVT = 'O', A is overwritten with the first min(m,n)",
       "                         rows of V**T (the right singular vectors,",
       "                         stored rowwise);",
       "         if JOBU .ne. 'O' and JOBVT .ne. 'O', the contents of A",
       "                         are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is DOUBLE PRECISION array, dimension (LDU,UCOL)",
       "         (LDU,M) if JOBU = 'A' or (LDU,min(M,N)) if JOBU = 'S'.",
       "         If JOBU = 'A', U contains the M-by-M orthogonal matrix U;",
       "         if JOBU = 'S', U contains the first min(m,n) columns of U",
       "         (the left singular vectors, stored columnwise);",
       "         if JOBU = 'N' or 'O', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1; if",
       "         JOBU = 'S' or 'A', LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is DOUBLE PRECISION array, dimension (LDVT,N)",
       "         If JOBVT = 'A', VT contains the N-by-N orthogonal matrix",
       "         V**T;",
       "         if JOBVT = 'S', VT contains the first min(m,n) rows of",
       "         V**T (the right singular vectors, stored rowwise);",
       "         if JOBVT = 'N' or 'O', VT is not referenced."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1; if",
       "         JOBVT = 'A', LDVT >= N; if JOBVT = 'S', LDVT >= min(M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK;",
       "         if INFO > 0, WORK(2:MIN(M,N)) contains the unconverged",
       "         superdiagonal elements of an upper bidiagonal matrix B",
       "         whose diagonal is in S (not necessarily sorted). B",
       "         satisfies A = U * B * VT, so it has the same singular values",
       "         as A, and singular vectors related by U and VT."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= MAX(1,5*MIN(M,N)) for the paths (see comments inside code):",
       "            - PATH 1  (M much larger than N, JOBU='N')",
       "            - PATH 1t (N much larger than M, JOBVT='N')",
       "         LWORK >= MAX(1,3*MIN(M,N) + MAX(M,N),5*MIN(M,N)) for the other paths",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if DBDSQR did not converge, INFO specifies how many",
       "               superdiagonals of an intermediate bidiagonal form B",
       "               did not converge to zero. See the description of WORK",
       "               above for details."]}},
 "chesv"=>
  {"summary"=>
    ["CHESV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS",
     "matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**H,  if UPLO = 'U', or",
     "   A = L * D * L**H,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is Hermitian and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.  The factored form of A is then",
     "used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**H or A = L*D*L**H as computed by",
       "         CHETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by CHETRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         CHETRF.",
       "         for LWORK < N, TRS will be done with Level BLAS 2",
       "         for LWORK >= N, TRS will be done with Level BLAS 3",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "slagts"=>
  {"summary"=>
    ["SLAGTS may be used to solve one of the systems of equations",
     "   (T - lambda*I)*x = y   or   (T - lambda*I)**T*x = y,",
     "where T is an n by n tridiagonal matrix, for x, following the",
     "factorization of (T - lambda*I) as",
     "   (T - lambda*I) = P*L*U ,",
     "by routine SLAGTF. The choice of equation to be solved is",
     "controlled by the argument JOB, and in each case there is an option",
     "to perturb zero or very small diagonal elements of U, this option",
     "being intended for use in applications such as inverse iteration."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is INTEGER",
       "         Specifies the job to be performed by SLAGTS as follows:",
       "         =  1: The equations  (T - lambda*I)x = y  are to be solved,",
       "               but diagonal elements of U are not to be perturbed.",
       "         = -1: The equations  (T - lambda*I)x = y  are to be solved",
       "               and, if overflow would otherwise occur, the diagonal",
       "               elements of U are to be perturbed. See argument TOL",
       "               below.",
       "         =  2: The equations  (T - lambda*I)**Tx = y  are to be solved,",
       "               but diagonal elements of U are not to be perturbed.",
       "         = -2: The equations  (T - lambda*I)**Tx = y  are to be solved",
       "               and, if overflow would otherwise occur, the diagonal",
       "               elements of U are to be perturbed. See argument TOL",
       "               below."],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix T."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (N)",
       "         On entry, A must contain the diagonal elements of U as",
       "         returned from SLAGTF."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (N-1)",
       "         On entry, B must contain the first super-diagonal elements of",
       "         U as returned from SLAGTF."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N-1)",
       "         On entry, C must contain the sub-diagonal elements of L as",
       "         returned from SLAGTF."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N-2)",
       "         On entry, D must contain the second super-diagonal elements",
       "         of U as returned from SLAGTF."],
     "IN"=>
      ["[in]",
       "         IN is INTEGER array, dimension (N)",
       "         On entry, IN must contain details of the matrix P as returned",
       "         from SLAGTF."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension (N)",
       "         On entry, the right hand side vector y.",
       "         On exit, Y is overwritten by the solution vector x."],
     "TOL"=>
      ["[in,out]",
       "         TOL is REAL",
       "         On entry, with  JOB .lt. 0, TOL should be the minimum",
       "         perturbation to be made to very small diagonal elements of U.",
       "         TOL should normally be chosen as about eps*norm(U), where eps",
       "         is the relative machine precision, but if TOL is supplied as",
       "         non-positive, then it is reset to eps*max( abs( u(i,j) ) ).",
       "         If  JOB .gt. 0  then TOL is not referenced.",
       "         On exit, TOL is changed as described above, only if TOL is",
       "         non-positive on entry. Otherwise TOL is unchanged."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0   : successful exit",
       "         .lt. 0: if INFO = -i, the i-th argument had an illegal value",
       "         .gt. 0: overflow would occur when computing the INFO(th)",
       "                 element of the solution vector x. This can only occur",
       "                 when JOB is supplied as positive and either means",
       "                 that a diagonal element of U is very small, or that",
       "                 the elements of the right-hand side vector y are very",
       "                 large."]}},
 "ztzrzf"=>
  {"summary"=>
    ["ZTZRZF reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A",
     "to upper triangular form by means of unitary transformations.",
     "The upper trapezoidal matrix A is factored as",
     "   A = ( R  0 ) * Z,",
     "where Z is an N-by-N unitary matrix and R is an M-by-M upper",
     "triangular matrix."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= M."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the leading M-by-N upper trapezoidal part of the",
       "         array A must contain the matrix to be factorized.",
       "         On exit, the leading M-by-M upper triangular part of A",
       "         contains the upper triangular matrix R, and elements M+1 to",
       "         N of the first M rows of A, with the array TAU, represent the",
       "         unitary matrix Z as a product of M elementary reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (M)",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slarfy"=>
  {"summary"=>
    ["SLARFY applies an elementary reflector, or Householder matrix, H,",
     "to an n x n symmetric matrix C, from both the left and the right.",
     "H is represented in the form",
     "   H = I - tau * v * v'",
     "where  tau  is a scalar and  v  is a vector.",
     "If  tau  is  zero, then  H  is taken to be the unit matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix C is stored.",
       "         = 'U':  Upper triangle",
       "         = 'L':  Lower triangle"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows and columns of the matrix C.  N >= 0."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension",
       "                 (1 + (N-1)*abs(INCV))",
       "         The vector v as described above."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between successive elements of v.  INCV must",
       "         not be zero."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL",
       "         The value tau as described above."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC, N)",
       "         On entry, the matrix C.",
       "         On exit, C is overwritten by H * C * H'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.  LDC >= max( 1, N )."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"]}},
 "dorgr2"=>
  {"summary"=>
    ["DORGR2 generates an m by n real matrix Q with orthonormal rows,",
     "which is defined as the last m rows of a product of k elementary",
     "reflectors of order n",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by DGERQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the (m-k+i)-th row must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by DGERQF in the last k rows of its array argument",
       "         A.",
       "         On exit, the m by n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGERQF."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "ssytrs2"=>
  {"summary"=>
    ["SSYTRS2 solves a system of linear equations A*X = B with a real",
     "symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by SSYTRF and converted by SSYCONV."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by SSYTRF.",
       "         Note that A is input / output. This might be counter-intuitive,",
       "         and one may think that A is input only. A is input / output. This",
       "         is because, at the start of the subroutine, we permute A in a",
       "         \"better\" form and then we permute A back to its original form at",
       "         the end."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgeqrt3"=>
  {"summary"=>
    ["CGEQRT3 recursively computes a QR factorization of a complex M-by-N matrix A,",
     "using the compact WY representation of Q.",
     "Based on the algorithm of Elmroth and Gustavson,",
     "IBM J. Res. Develop. Vol 44 No. 4 July 2000."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the complex M-by-N matrix A.  On exit, the elements on and",
       "         above the diagonal contain the N-by-N upper triangular matrix R; the",
       "         elements below the diagonal are the columns of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dsysv"=>
  {"summary"=>
    ["DSYSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.  The factored form of A is then",
     "used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**T or A = L*D*L**T as computed by",
       "         DSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by DSYTRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         DSYTRF.",
       "         for LWORK < N, TRS will be done with Level BLAS 2",
       "         for LWORK >= N, TRS will be done with Level BLAS 3",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "dsb2st_kernels"=>
  {"summary"=>
    ["DSB2ST_KERNELS is an internal routine used by the DSYTRD_SB2ST",
     "subroutine."],
   "param"=>nil},
 "dlansp"=>
  {"summary"=>
    ["DLANSP  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "real symmetric matrix A,  supplied in packed form.",
     "   DLANSP = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANSP as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is supplied.",
       "         = 'U':  Upper triangular part of A is supplied",
       "         = 'L':  Lower triangular part of A is supplied"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, DLANSP is",
       "         set to zero."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "clanht"=>
  {"summary"=>
    ["CLANHT  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex Hermitian tridiagonal matrix A.",
     "   CLANHT = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANHT as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANHT is",
       "         set to zero."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of A."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N-1)",
       "         The (n-1) sub-diagonal or super-diagonal elements of A."]}},
 "dgesc2"=>
  {"summary"=>
    ["DGESC2 solves a system of linear equations",
     "          A * X = scale* RHS",
     "with a general N-by-N matrix A using the LU factorization with",
     "complete pivoting computed by DGETC2."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the  LU part of the factorization of the n-by-n",
       "         matrix A computed by DGETC2:  A = P * L * U * Q"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1, N)."],
     "RHS"=>
      ["[in,out]",
       "         RHS is DOUBLE PRECISION array, dimension (N).",
       "         On entry, the right hand side vector b.",
       "         On exit, the solution vector X."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[in]",
       "         JPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         On exit, SCALE contains the scale factor. SCALE is chosen",
       "         0 <= SCALE <= 1 to prevent owerflow in the solution."]}},
 "stpmqrt"=>
  {"summary"=>
    ["STPMQRT applies a real orthogonal matrix Q obtained from a",
     "\"triangular-pentagonal\" real block reflector H to a general",
     "real matrix C, which consists of two blocks A and B."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q^T from the Left;",
       "         = 'R': apply Q or Q^T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q^T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size used for the storage of T.  K >= NB >= 1.",
       "         This must be the same value of NB used to generate T",
       "         in CTPQRT."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CTPQRT in B.  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDV >= max(1,M);",
       "         if SIDE = 'R', LDV >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by CTPQRT, stored as a NB-by-K matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension",
       "         (LDA,N) if SIDE = 'L' or",
       "         (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         Q*C or Q^T*C or C*Q or C*Q^T.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         Q*C or Q^T*C or C*Q or C*Q^T.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array. The dimension of WORK is",
       "          N*NB if SIDE = 'L', or  M*NB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chbgvx"=>
  {"summary"=>
    ["CHBGVX computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite banded eigenproblem, of",
     "the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian",
     "and banded, and B is also positive definite.  Eigenvalues and",
     "eigenvectors can be selected by specifying either all eigenvalues,",
     "a range of values or a range of indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is COMPLEX array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(kb+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**H*S, as returned by CPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the n-by-n matrix used in the reduction of",
       "         A*x = (lambda)*B*x to standard form, i.e. C*x = (lambda)*x,",
       "         and consequently C to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'N',",
       "         LDQ >= 1. If JOBZ = 'V', LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AP to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i). The eigenvectors are",
       "         normalized so that Z**H*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= N."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is:",
       "            <= N:  then i eigenvectors failed to converge.  Their",
       "                   indices are stored in array IFAIL.",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then CPBSTF",
       "                   returned INFO = i: B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "zlauum"=>
  {"summary"=>
    ["ZLAUUM computes the product U * U**H or L**H * L, where the triangular",
     "factor U or L is stored in the upper or lower triangular part of",
     "the array A.",
     "If UPLO = 'U' or 'u' then the upper triangle of the result is stored,",
     "overwriting the factor U in A.",
     "If UPLO = 'L' or 'l' then the lower triangle of the result is stored,",
     "overwriting the factor L in A.",
     "This is the blocked form of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the triangular factor stored in the array A",
       "         is upper or lower triangular:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the triangular factor U or L.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L.",
       "         On exit, if UPLO = 'U', the upper triangle of A is",
       "         overwritten with the upper triangle of the product U * U**H;",
       "         if UPLO = 'L', the lower triangle of A is overwritten with",
       "         the lower triangle of the product L**H * L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "ssytrs_rook"=>
  {"summary"=>
    ["SSYTRS_ROOK solves a system of linear equations A*X = B with",
     "a real symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by SSYTRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by SSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF_ROOK."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlasd6"=>
  {"summary"=>
    ["DLASD6 computes the SVD of an updated upper bidiagonal matrix B",
     "obtained by merging two smaller ones by appending a row. This",
     "routine is used only for the problem which requires all singular",
     "values and optionally singular vector matrices in factored form.",
     "B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE.",
     "A related subroutine, DLASD1, handles the case in which all singular",
     "values and singular vectors of the bidiagonal matrix are desired.",
     "DLASD6 computes the SVD as follows:",
     "              ( D1(in)    0    0       0 )",
     "  B = U(in) * (   Z1**T   a   Z2**T    b ) * VT(in)",
     "              (   0       0   D2(in)   0 )",
     "    = U(out) * ( D(out) 0) * VT(out)",
     "where Z**T = (Z1**T a Z2**T b) = u**T VT**T, and u is a vector of dimension M",
     "with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros",
     "elsewhere; and the entry b is empty if SQRE = 0.",
     "The singular values of B can be computed using D1, D2, the first",
     "components of all the right singular vectors of the lower block, and",
     "the last components of all the right singular vectors of the upper",
     "block. These components are stored and updated in VF and VL,",
     "respectively, in DLASD6. Hence U and VT are not explicitly",
     "referenced.",
     "The singular values are stored in D. The algorithm consists of two",
     "stages:",
     "      The first stage consists of deflating the size of the problem",
     "      when there are multiple singular values or if there is a zero",
     "      in the Z vector. For each such occurrence the dimension of the",
     "      secular equation problem is reduced by one. This stage is",
     "      performed by the routine DLASD7.",
     "      The second stage consists of calculating the updated",
     "      singular values. This is done by finding the roots of the",
     "      secular equation via the routine DLASD4 (as called by DLASD8).",
     "      This routine also updates VF and VL and computes the distances",
     "      between the updated singular values and the old singular",
     "      values.",
     "DLASD6 is called from DLASDA."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether singular vectors are to be computed in",
       "        factored form:",
       "        = 0: Compute singular values only.",
       "        = 1: Compute singular vectors in factored form as well."],
     "NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block.  NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block.  NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has row dimension N = NL + NR + 1,",
       "        and column dimension M = N + SQRE."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension ( NL+NR+1 ).",
       "        On entry D(1:NL,1:NL) contains the singular values of the",
       "        upper block, and D(NL+2:N) contains the singular values",
       "        of the lower block. On exit D(1:N) contains the singular",
       "        values of the modified matrix."],
     "VF"=>
      ["[in,out]",
       "         VF is DOUBLE PRECISION array, dimension ( M )",
       "        On entry, VF(1:NL+1) contains the first components of all",
       "        right singular vectors of the upper block; and VF(NL+2:M)",
       "        contains the first components of all right singular vectors",
       "        of the lower block. On exit, VF contains the first components",
       "        of all right singular vectors of the bidiagonal matrix."],
     "VL"=>
      ["[in,out]",
       "         VL is DOUBLE PRECISION array, dimension ( M )",
       "        On entry, VL(1:NL+1) contains the  last components of all",
       "        right singular vectors of the upper block; and VL(NL+2:M)",
       "        contains the last components of all right singular vectors of",
       "        the lower block. On exit, VL contains the last components of",
       "        all right singular vectors of the bidiagonal matrix."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is DOUBLE PRECISION",
       "        Contains the diagonal element associated with the added row."],
     "BETA"=>
      ["[in,out]",
       "         BETA is DOUBLE PRECISION",
       "        Contains the off-diagonal element associated with the added",
       "        row."],
     "IDXQ"=>
      ["[in,out]",
       "         IDXQ is INTEGER array, dimension ( N )",
       "        This contains the permutation which will reintegrate the",
       "        subproblem just solved back into sorted order, i.e.",
       "        D( IDXQ( I = 1, N ) ) will be in ascending order."],
     "PERM"=>
      ["[out]",
       "         PERM is INTEGER array, dimension ( N )",
       "        The permutations (from deflation and sorting) to be applied",
       "        to each block. Not referenced if ICOMPQ = 0."],
     "GIVPTR"=>
      ["[out]",
       "         GIVPTR is INTEGER",
       "        The number of Givens rotations which took place in this",
       "        subproblem. Not referenced if ICOMPQ = 0."],
     "GIVCOL"=>
      ["[out]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation. Not referenced if ICOMPQ = 0."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER",
       "        leading dimension of GIVCOL, must be at least N."],
     "GIVNUM"=>
      ["[out]",
       "         GIVNUM is DOUBLE PRECISION array, dimension ( LDGNUM, 2 )",
       "        Each number indicates the C or S value to be used in the",
       "        corresponding Givens rotation. Not referenced if ICOMPQ = 0."],
     "LDGNUM"=>
      ["[in]",
       "         LDGNUM is INTEGER",
       "        The leading dimension of GIVNUM and POLES, must be at least N."],
     "POLES"=>
      ["[out]",
       "         POLES is DOUBLE PRECISION array, dimension ( LDGNUM, 2 )",
       "        On exit, POLES(1,*) is an array containing the new singular",
       "        values obtained from solving the secular equation, and",
       "        POLES(2,*) is an array containing the poles in the secular",
       "        equation. Not referenced if ICOMPQ = 0."],
     "DIFL"=>
      ["[out]",
       "         DIFL is DOUBLE PRECISION array, dimension ( N )",
       "        On exit, DIFL(I) is the distance between I-th updated",
       "        (undeflated) singular value and the I-th (undeflated) old",
       "        singular value."],
     "DIFR"=>
      ["[out]",
       "         DIFR is DOUBLE PRECISION array,",
       "                  dimension ( LDDIFR, 2 ) if ICOMPQ = 1 and",
       "                  dimension ( K ) if ICOMPQ = 0.",
       "         On exit, DIFR(I,1) = D(I) - DSIGMA(I+1), DIFR(K,1) is not",
       "         defined and will not be referenced.",
       "         If ICOMPQ = 1, DIFR(1:K,2) is an array containing the",
       "         normalizing factors for the right singular vector matrix.",
       "        See DLASD8 for details on DIFL and DIFR."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension ( M )",
       "        The first elements of this array contain the components",
       "        of the deflation-adjusted updating row vector."],
     "K"=>
      ["[out]",
       "         K is INTEGER",
       "        Contains the dimension of the non-deflated matrix,",
       "        This is the order of the related secular equation. 1 <= K <=N."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION",
       "        C contains garbage if SQRE =0 and the C-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION",
       "        S contains garbage if SQRE =0 and the S-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension ( 4 * M )"],
     "IWORK"=>
      ["[out]", "         IWORK is INTEGER array, dimension ( 3 * N )"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, a singular value did not converge"]}},
 "zlaqr3"=>
  {"summary"=>
    ["   Aggressive early deflation:",
     "   ZLAQR3 accepts as input an upper Hessenberg matrix",
     "   H and performs an unitary similarity transformation",
     "   designed to detect and deflate fully converged eigenvalues from",
     "   a trailing principal submatrix.  On output H has been over-",
     "   written by a new Hessenberg matrix that is a perturbation of",
     "   an unitary similarity transformation of H.  It is to be",
     "   hoped that the final version of H has many zero subdiagonal",
     "   entries."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         If .TRUE., then the Hessenberg matrix H is fully updated",
       "         so that the triangular Schur factor may be",
       "         computed (in cooperation with the calling subroutine).",
       "         If .FALSE., then only enough of H is updated to preserve",
       "         the eigenvalues."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         If .TRUE., then the unitary matrix Z is updated so",
       "         so that the unitary Schur factor may be computed",
       "         (in cooperation with the calling subroutine).",
       "         If .FALSE., then Z is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H and (if WANTZ is .TRUE.) the",
       "         order of the unitary matrix Z."],
     "KTOP"=>
      ["[in]",
       "         KTOP is INTEGER",
       "         It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.",
       "         KBOT and KTOP together determine an isolated block",
       "         along the diagonal of the Hessenberg matrix."],
     "KBOT"=>
      ["[in]",
       "         KBOT is INTEGER",
       "         It is assumed without a check that either",
       "         KBOT = N or H(KBOT+1,KBOT)=0.  KBOT and KTOP together",
       "         determine an isolated block along the diagonal of the",
       "         Hessenberg matrix."],
     "NW"=>
      ["[in]",
       "         NW is INTEGER",
       "         Deflation window size.  1 .LE. NW .LE. (KBOT-KTOP+1)."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX*16 array, dimension (LDH,N)",
       "         On input the initial N-by-N section of H stores the",
       "         Hessenberg matrix undergoing aggressive early deflation.",
       "         On output H has been transformed by a unitary",
       "         similarity transformation, perturbed, and the returned",
       "         to Hessenberg form that (it is to be hoped) has some",
       "         zero subdiagonal entries."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "         Leading dimension of H just as declared in the calling",
       "         subroutine.  N .LE. LDH"],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ,N)",
       "         IF WANTZ is .TRUE., then on output, the unitary",
       "         similarity transformation mentioned above has been",
       "         accumulated into Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "         If WANTZ is .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer",
       "         The leading dimension of Z just as declared in the",
       "         calling subroutine.  1 .LE. LDZ."],
     "NS"=>
      ["[out]",
       "         NS is integer",
       "         The number of unconverged (ie approximate) eigenvalues",
       "         returned in SR and SI that may be used as shifts by the",
       "         calling subroutine."],
     "ND"=>
      ["[out]",
       "         ND is integer",
       "         The number of converged eigenvalues uncovered by this",
       "         subroutine."],
     "SH"=>
      ["[out]",
       "         SH is COMPLEX*16 array, dimension KBOT",
       "         On output, approximate eigenvalues that may",
       "         be used for shifts are stored in SH(KBOT-ND-NS+1)",
       "         through SR(KBOT-ND).  Converged eigenvalues are",
       "         stored in SH(KBOT-ND+1) through SH(KBOT)."],
     "V"=>
      ["[out]",
       "         V is COMPLEX*16 array, dimension (LDV,NW)",
       "         An NW-by-NW work array."],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "         The leading dimension of V just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "         The number of columns of T.  NH.GE.NW."],
     "T"=>["[out]", "         T is COMPLEX*16 array, dimension (LDT,NW)"],
     "LDT"=>
      ["[in]",
       "         LDT is integer",
       "         The leading dimension of T just as declared in the",
       "         calling subroutine.  NW .LE. LDT"],
     "NV"=>
      ["[in]",
       "         NV is integer",
       "         The number of rows of work array WV available for",
       "         workspace.  NV.GE.NW."],
     "WV"=>["[out]", "         WV is COMPLEX*16 array, dimension (LDWV,NW)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer",
       "         The leading dimension of W just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension LWORK.",
       "         On exit, WORK(1) is set to an estimate of the optimal value",
       "         of LWORK for the given values of N, NW, KTOP and KBOT."],
     "LWORK"=>
      ["[in]",
       "         LWORK is integer",
       "         The dimension of the work array WORK.  LWORK = 2*NW",
       "         suffices, but greater efficiency may result from larger",
       "         values of LWORK.",
       "         If LWORK = -1, then a workspace query is assumed; ZLAQR3",
       "         only estimates the optimal workspace size for the given",
       "         values of N, NW, KTOP and KBOT.  The estimate is returned",
       "         in WORK(1).  No error message related to LWORK is issued",
       "         by XERBLA.  Neither H nor Z are accessed."]}},
 "cpftrs"=>
  {"summary"=>
    ["CPFTRS solves a system of linear equations A*X = B with a Hermitian",
     "positive definite matrix A using the Cholesky factorization",
     "A = U**H*U or A = L*L**H computed by CPFTRF."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of RFP A is stored;",
       "         = 'L':  Lower triangle of RFP A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension ( N*(N+1)/2 );",
       "         The triangular factor U or L from the Cholesky factorization",
       "         of RFP A = U**H*U or RFP A = L*L**H, as computed by CPFTRF.",
       "         See note below for more details about RFP A."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlasyf_rk"=>
  {"summary"=>
    ["DLASYF_RK computes a partial factorization of a real symmetric",
     "matrix A using the bounded Bunch-Kaufman (rook) diagonal",
     "pivoting method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**T L21**T )  if UPLO = 'L',",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "DLASYF_RK is an auxiliary routine called by DSYTRF_RK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,N-KB+1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,1:KB).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "W"=>
      ["[out]", "         W is DOUBLE PRECISION array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "cheevr"=>
  {"summary"=>
    ["CHEEVR computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian matrix A.  Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues.",
     "CHEEVR first reduces the matrix A to tridiagonal form T with a call",
     "to CHETRD.  Then, whenever possible, CHEEVR calls CSTEMR to compute",
     "the eigenspectrum using Relatively Robust Representations.  CSTEMR",
     "computes eigenvalues by the dqds algorithm, while orthogonal",
     "eigenvectors are computed from various \"good\" L D L^T representations",
     "(also known as Relatively Robust Representations). Gram-Schmidt",
     "orthogonalization is avoided as far as possible. More specifically,",
     "the various steps of the algorithm are as follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "The desired accuracy of the output can be specified by the input",
     "parameter ABSTOL.",
     "For more details, see DSTEMR's documentation and:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Note 1 : CHEEVR calls CSTEMR when the full spectrum is requested",
     "on machines which conform to the ieee-754 floating point standard.",
     "CHEEVR calls SSTEBZ and CSTEIN on non-ieee machines and",
     "when partial spectrum requests are made.",
     "Normal execution of CSTEMR may create NaNs and infinities and",
     "hence may abort due to a floating point exception in environments",
     "which do not handle NaNs and infinities in the ieee standard default",
     "manner."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found.",
       "         For RANGE = 'V' or 'I' and IU - IL < N - 1, SSTEBZ and",
       "         CSTEIN are called"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3.",
       "         If high relative accuracy is important, set ABSTOL to",
       "         SLAMCH( 'Safe minimum' ).  Doing so will guarantee that",
       "         eigenvalues are computed to high relative accuracy when",
       "         possible in future releases.  The current code does not",
       "         make any guarantees about high relative accuracy, but",
       "         furutre releases will. See J. Barlow and J. Demmel,",
       "         \"Computing Accurate Eigensystems of Scaled Diagonally",
       "         Dominant Matrices\", LAPACK Working Note #7, for a discussion",
       "         of which matrices define their eigenvalues to high relative",
       "         accuracy."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is an output of CSTEMR (tridiagonal",
       "         matrix). The support of the eigenvectors of A is typically",
       "         1:N because of the unitary transformations applied by CUNMTR.",
       "         Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1"],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,2*N).",
       "         For optimal efficiency, LWORK >= (NB+1)*N,",
       "         where NB is the max of the blocksize for CHETRD and for",
       "         CUNMTR as returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal",
       "         (and minimal) LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The length of the array RWORK.  LRWORK >= max(1,24*N).",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal",
       "         (and minimal) LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  Internal error"]}},
 "dlasyf_aa"=>
  {"summary"=>
    ["DLATRF_AA factorizes a panel of a real symmetric matrix A using",
     "the Aasen's algorithm. The panel consists of a set of NB rows of A",
     "when UPLO is U, or a set of NB columns when UPLO is L.",
     "In order to factorize the panel, the Aasen's algorithm requires the",
     "last row, or column, of the previous panel. The first row, or column,",
     "of A is set to be the first row, or column, of an identity matrix,",
     "which is used to factorize the first panel.",
     "The resulting J-th row of U, or J-th column of L, is stored in the",
     "(J-1)-th row, or column, of A (without the unit diagonals), while",
     "the diagonal and subdiagonal of A are overwritten by those of T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The location of the first row, or column, of the panel",
       "         within the submatrix of A, passed to this routine, e.g.,",
       "         when called by DSYTRF_AA, for the first panel, J1 is 1,",
       "         while for the remaining panels, J1 is 2."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The dimension of the submatrix. M >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The dimension of the panel to be facotorized."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,M) for",
       "         the first panel, while dimension (LDA,M+1) for the",
       "         remaining panels.",
       "         On entry, A contains the last row, or column, of",
       "         the previous panel, and the trailing submatrix of A",
       "         to be factorized, except for the first panel, only",
       "         the panel is passed.",
       "         On exit, the leading panel is factorized."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the row and column interchanges,",
       "         the row and column k were interchanged with the row and",
       "         column IPIV(k)."],
     "H"=>
      ["[in,out]",
       "         H is DOUBLE PRECISION workspace, dimension (LDH,NB)."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the workspace H. LDH >= max(1,M)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION workspace, dimension (M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "stprfs"=>
  {"summary"=>
    ["STPRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular packed",
     "coefficient matrix.",
     "The solution matrix X must be computed by STPTRS or some other",
     "means before entering this routine.  STPRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgelss"=>
  {"summary"=>
    ["DGELSS computes the minimum norm solution to a real linear least",
     "squares problem:",
     "Minimize 2-norm(| b - A*x |).",
     "using the singular value decomposition (SVD) of A. A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix",
     "X.",
     "The effective rank of A is determined by treating as zero those",
     "singular values which are less than RCOND times the largest singular",
     "value."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the first min(m,n) rows of A are overwritten with",
       "         its right singular vectors, stored rowwise."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, B is overwritten by the N-by-NRHS solution",
       "         matrix X.  If m >= n and RANK = n, the residual",
       "         sum-of-squares for the solution in the i-th column is given",
       "         by the sum of squares of elements n+1:m in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,max(M,N))."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The singular values of A in decreasing order.",
       "         The condition number of A in the 2-norm = S(1)/S(min(m,n))."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "         RCOND is used to determine the effective rank of A.",
       "         Singular values S(i) <= RCOND*S(1) are treated as zero.",
       "         If RCOND < 0, machine precision is used instead."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the number of singular values",
       "         which are greater than RCOND*S(1)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= 1, and also:",
       "         LWORK >= 3*min(M,N) + max( 2*min(M,N), max(M,N), NRHS )",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  the algorithm for computing the SVD failed to converge;",
       "               if INFO = i, i off-diagonal elements of an intermediate",
       "               bidiagonal form did not converge to zero."]}},
 "dlansb"=>
  {"summary"=>
    ["DLANSB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n symmetric band matrix A,  with k super-diagonals.",
     "   DLANSB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANSB as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         band matrix A is supplied.",
       "         = 'U':  Upper triangular part is supplied",
       "         = 'L':  Lower triangular part is supplied"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, DLANSB is",
       "         set to zero."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of super-diagonals or sub-diagonals of the",
       "         band matrix A.  K >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The upper or lower triangle of the symmetric band matrix A,",
       "         stored in the first K+1 rows of AB.  The j-th column of A is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)   = A(i,j) for j<=i<=min(n,j+k)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= K+1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "chbevx_2stage"=>
  {"summary"=>
    ["CHBEVX_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian band matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  Eigenvalues and eigenvectors",
     "can be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX array, dimension (LDQ, N)",
       "         If JOBZ = 'V', the N-by-N unitary matrix used in the",
       "                         reduction to tridiagonal form.",
       "         If JOBZ = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  If JOBZ = 'V', then",
       "         LDQ >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AB to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "slasy2"=>
  {"summary"=>
    ["SLASY2 solves for the N1 by N2 matrix X, 1 <= N1,N2 <= 2, in",
     "       op(TL)*X + ISGN*X*op(TR) = SCALE*B,",
     "where TL is N1 by N1, TR is N2 by N2, B is N1 by N2, and ISGN = 1 or",
     "-1.  op(T) = T or T**T, where T**T denotes the transpose of T."],
   "param"=>
    {"LTRANL"=>
      ["[in]",
       "         LTRANL is LOGICAL",
       "         On entry, LTRANL specifies the op(TL):",
       "            = .FALSE., op(TL) = TL,",
       "            = .TRUE., op(TL) = TL**T."],
     "LTRANR"=>
      ["[in]",
       "         LTRANR is LOGICAL",
       "         On entry, LTRANR specifies the op(TR):",
       "           = .FALSE., op(TR) = TR,",
       "           = .TRUE., op(TR) = TR**T."],
     "ISGN"=>
      ["[in]",
       "         ISGN is INTEGER",
       "         On entry, ISGN specifies the sign of the equation",
       "         as described before. ISGN may only be 1 or -1."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         On entry, N1 specifies the order of matrix TL.",
       "         N1 may only be 0, 1 or 2."],
     "N2"=>
      ["[in]",
       "         N2 is INTEGER",
       "         On entry, N2 specifies the order of matrix TR.",
       "         N2 may only be 0, 1 or 2."],
     "TL"=>
      ["[in]",
       "         TL is REAL array, dimension (LDTL,2)",
       "         On entry, TL contains an N1 by N1 matrix."],
     "LDTL"=>
      ["[in]",
       "         LDTL is INTEGER",
       "         The leading dimension of the matrix TL. LDTL >= max(1,N1)."],
     "TR"=>
      ["[in]",
       "         TR is REAL array, dimension (LDTR,2)",
       "         On entry, TR contains an N2 by N2 matrix."],
     "LDTR"=>
      ["[in]",
       "         LDTR is INTEGER",
       "         The leading dimension of the matrix TR. LDTR >= max(1,N2)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,2)",
       "         On entry, the N1 by N2 matrix B contains the right-hand",
       "         side of the equation."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the matrix B. LDB >= max(1,N1)."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         On exit, SCALE contains the scale factor. SCALE is chosen",
       "         less than or equal to 1 to prevent the solution overflowing."],
     "X"=>
      ["[out]",
       "         X is REAL array, dimension (LDX,2)",
       "         On exit, X contains the N1 by N2 solution."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the matrix X. LDX >= max(1,N1)."],
     "XNORM"=>
      ["[out]",
       "         XNORM is REAL",
       "         On exit, XNORM is the infinity-norm of the solution."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO is set to",
       "            0: successful exit.",
       "            1: TL and TR have too close eigenvalues, so TL or",
       "               TR is perturbed to get a nonsingular equation.",
       "         NOTE: In the interests of speed, this routine does not",
       "               check the inputs for errors."]}},
 "dgebak"=>
  {"summary"=>
    ["DGEBAK forms the right or left eigenvectors of a real general matrix",
     "by backward transformation on the computed eigenvectors of the",
     "balanced matrix output by DGEBAL."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the type of backward transformation required:",
       "         = 'N', do nothing, return immediately;",
       "         = 'P', do backward transformation for permutation only;",
       "         = 'S', do backward transformation for scaling only;",
       "         = 'B', do backward transformations for both permutation and",
       "                scaling.",
       "         JOB must be the same as the argument JOB supplied to DGEBAL."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  V contains right eigenvectors;",
       "         = 'L':  V contains left eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrix V.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         The integers ILO and IHI determined by DGEBAL.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "SCALE"=>
      ["[in]",
       "         SCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutation and scaling factors, as returned",
       "         by DGEBAL."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix V.  M >= 0."],
     "V"=>
      ["[in,out]",
       "         V is DOUBLE PRECISION array, dimension (LDV,M)",
       "         On entry, the matrix of right or left eigenvectors to be",
       "         transformed, as returned by DHSEIN or DTREVC.",
       "         On exit, V is overwritten by the transformed eigenvectors."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zlahqr"=>
  {"summary"=>
    ["   ZLAHQR is an auxiliary routine called by CHSEQR to update the",
     "   eigenvalues and Schur decomposition already computed by CHSEQR, by",
     "   dealing with the Hessenberg submatrix in rows and columns ILO to",
     "   IHI."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that H is already upper triangular in rows and",
       "         columns IHI+1:N, and that H(ILO,ILO-1) = 0 (unless ILO = 1).",
       "         ZLAHQR works primarily with the Hessenberg submatrix in rows",
       "         and columns ILO to IHI, but applies transformations to all of",
       "         H if WANTT is .TRUE..",
       "         1 <= ILO <= max(1,IHI); IHI <= N."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX*16 array, dimension (LDH,N)",
       "         On entry, the upper Hessenberg matrix H.",
       "         On exit, if INFO is zero and if WANTT is .TRUE., then H",
       "         is upper triangular in rows and columns ILO:IHI.  If INFO",
       "         is zero and if WANTT is .FALSE., then the contents of H",
       "         are unspecified on exit.  The output state of H in case",
       "         INF is positive is below under the description of INFO."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H. LDH >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX*16 array, dimension (N)",
       "         The computed eigenvalues ILO to IHI are stored in the",
       "         corresponding elements of W. If WANTT is .TRUE., the",
       "         eigenvalues are stored in the same order as on the diagonal",
       "         of the Schur form returned in H, with W(i) = H(i,i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE..",
       "         1 <= ILOZ <= ILO; IHI <= IHIZ <= N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ,N)",
       "         If WANTZ is .TRUE., on entry Z must contain the current",
       "         matrix Z of transformations accumulated by CHSEQR, and on",
       "         exit Z has been updated; transformations are applied only to",
       "         the submatrix Z(ILOZ:IHIZ,ILO:IHI).",
       "         If WANTZ is .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          =   0: successful exit",
       "         .GT. 0: if INFO = i, ZLAHQR failed to compute all the",
       "                 eigenvalues ILO to IHI in a total of 30 iterations",
       "                 per eigenvalue; elements i+1:ihi of W contain",
       "                 those eigenvalues which have been successfully",
       "                 computed.",
       "                 If INFO .GT. 0 and WANTT is .FALSE., then on exit,",
       "                 the remaining unconverged eigenvalues are the",
       "                 eigenvalues of the upper Hessenberg matrix",
       "                 rows and columns ILO thorugh INFO of the final,",
       "                 output value of H.",
       "                 If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "         (*)       (initial value of H)*U  = U*(final value of H)",
       "                 where U is an orthognal matrix.    The final",
       "                 value of H is upper Hessenberg and triangular in",
       "                 rows and columns INFO+1 through IHI.",
       "                 If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                     (final value of Z)  = (initial value of Z)*U",
       "                 where U is the orthogonal matrix in (*)",
       "                 (regardless of the value of WANTT.)"]}},
 "zhesv"=>
  {"summary"=>
    ["ZHESV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS",
     "matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**H,  if UPLO = 'U', or",
     "   A = L * D * L**H,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is Hermitian and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.  The factored form of A is then",
     "used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**H or A = L*D*L**H as computed by",
       "         ZHETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by ZHETRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         ZHETRF.",
       "         for LWORK < N, TRS will be done with Level BLAS 2",
       "         for LWORK >= N, TRS will be done with Level BLAS 3",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "ztrevc3"=>
  {"summary"=>
    ["ZTREVC3 computes some or all of the right and/or left eigenvectors of",
     "a complex upper triangular matrix T.",
     "Matrices of this type are produced by the Schur factorization of",
     "a complex general matrix:  A = Q*T*Q**H, as computed by ZHSEQR.",
     "The right eigenvector x and the left eigenvector y of T corresponding",
     "to an eigenvalue w are defined by:",
     "             T*x = w*x,     (y**H)*T = w*(y**H)",
     "where y**H denotes the conjugate transpose of the vector y.",
     "The eigenvalues are not input to this routine, but are read directly",
     "from the diagonal of T.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an",
     "input matrix. If Q is the unitary factor that reduces a matrix A to",
     "Schur form T, then Q*X and Q*Y are the matrices of right and left",
     "eigenvectors of A.",
     "This uses a Level 3 BLAS version of the back transformation."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  compute right eigenvectors only;",
       "         = 'L':  compute left eigenvectors only;",
       "         = 'B':  compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A':  compute all right and/or left eigenvectors;",
       "         = 'B':  compute all right and/or left eigenvectors,",
       "                 backtransformed using the matrices supplied in",
       "                 VR and/or VL;",
       "         = 'S':  compute selected right and/or left eigenvectors,",
       "                 as indicated by the logical array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenvectors to be",
       "         computed.",
       "         The eigenvector corresponding to the j-th eigenvalue is",
       "         computed if SELECT(j) = .TRUE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in,out]",
       "         T is COMPLEX*16 array, dimension (LDT,N)",
       "         The upper triangular matrix T.  T is modified, but restored",
       "         on exit."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is COMPLEX*16 array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Q of",
       "         Schur vectors returned by ZHSEQR).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VL, in the same order as their",
       "                          eigenvalues.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= 1, and if SIDE = 'L' or 'B', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is COMPLEX*16 array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Q of",
       "         Schur vectors returned by ZHSEQR).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*X;",
       "         if HOWMNY = 'S', the right eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VR, in the same order as their",
       "                          eigenvalues.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= 1, and if SIDE = 'R' or 'B', LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.",
       "         If HOWMNY = 'A' or 'B', M is set to N.",
       "         Each selected eigenvector occupies one column."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of array WORK. LWORK >= max(1,2*N).",
       "         For optimum performance, LWORK >= N + 2*N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (LRWORK)"],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK. LRWORK >= max(1,N).",
       "         If LRWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the RWORK array, returns",
       "         this value as the first entry of the RWORK array, and no error",
       "         message related to LRWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ztptri"=>
  {"summary"=>
    ["ZTPTRI computes the inverse of a complex upper or lower triangular",
     "matrix A stored in packed format."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangular matrix A, stored",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*((2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same packed storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, A(i,i) is exactly zero.  The triangular",
       "               matrix is singular and its inverse can not be computed."]}},
 "cgeqlf"=>
  {"summary"=>
    ["CGEQLF computes a QL factorization of a complex M-by-N matrix A:",
     "A = Q * L."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if m >= n, the lower triangle of the subarray",
       "         A(m-n+1:m,1:n) contains the N-by-N lower triangular matrix L;",
       "         if m <= n, the elements on and below the (n-m)-th",
       "         superdiagonal contain the M-by-N lower trapezoidal matrix L;",
       "         the remaining elements, with the array TAU, represent the",
       "         unitary matrix Q as a product of elementary reflectors",
       "         (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaqsy"=>
  {"summary"=>
    ["DLAQSY equilibrates a symmetric matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if EQUED = 'Y', the equilibrated matrix:",
       "         diag(S) * A * diag(S)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is DOUBLE PRECISION",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "dsbev"=>
  {"summary"=>
    ["DSBEV computes all the eigenvalues and, optionally, eigenvectors of",
     "a real symmetric band matrix A."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (max(1,3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dstedc"=>
  {"summary"=>
    ["DSTEDC computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric tridiagonal matrix using the divide and conquer method.",
     "The eigenvectors of a full or band real symmetric matrix can also be",
     "found if DSYTRD or DSPTRD or DSBTRD has been used to reduce this",
     "matrix to tridiagonal form.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none.  See DLAED3 for details."],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'I':  Compute eigenvectors of tridiagonal matrix also.",
       "         = 'V':  Compute eigenvectors of original dense symmetric",
       "                 matrix also.  On entry, Z contains the orthogonal",
       "                 matrix used to reduce the original matrix to",
       "                 tridiagonal form."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the diagonal elements of the tridiagonal matrix.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the subdiagonal elements of the tridiagonal matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ,N)",
       "         On entry, if COMPZ = 'V', then Z contains the orthogonal",
       "         matrix used in the reduction to tridiagonal form.",
       "         On exit, if INFO = 0, then if COMPZ = 'V', Z contains the",
       "         orthonormal eigenvectors of the original symmetric matrix,",
       "         and if COMPZ = 'I', Z contains the orthonormal eigenvectors",
       "         of the symmetric tridiagonal matrix.",
       "         If  COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1.",
       "         If eigenvectors are desired, then LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array,",
       "                                        dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If COMPZ = 'N' or N <= 1 then LWORK must be at least 1.",
       "         If COMPZ = 'V' and N > 1 then LWORK must be at least",
       "                        ( 1 + 3*N + 2*N*lg N + 4*N**2 ),",
       "                        where lg( N ) = smallest integer k such",
       "                        that 2**k >= N.",
       "         If COMPZ = 'I' and N > 1 then LWORK must be at least",
       "                        ( 1 + 4*N + N**2 ).",
       "         Note that for COMPZ = 'I' or 'V', then if N is less than or",
       "         equal to the minimum divide size, usually 25, then LWORK need",
       "         only be max(1,2*(N-1)).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If COMPZ = 'N' or N <= 1 then LIWORK must be at least 1.",
       "         If COMPZ = 'V' and N > 1 then LIWORK must be at least",
       "                        ( 6 + 6*N + 5*N*lg N ).",
       "         If COMPZ = 'I' and N > 1 then LIWORK must be at least",
       "                        ( 3 + 5*N ).",
       "         Note that for COMPZ = 'I' or 'V', then if N is less than or",
       "         equal to the minimum divide size, usually 25, then LIWORK",
       "         need only be 1.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The algorithm failed to compute an eigenvalue while",
       "               working on the submatrix lying in rows and columns",
       "               INFO/(N+1) through mod(INFO,N+1)."]}},
 "cla_syrfsx_extended"=>
  {"summary"=>
    ["CLA_SYRFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by CSYRFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by CSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by CSYTRF."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension",
       "                   (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by CSYTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is REAL array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by CLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is REAL array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is REAL array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]", "         AYB is REAL array, dimension (N)", "    Workspace."],
     "DY"=>
      ["[in]",
       "         DY is COMPLEX array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is COMPLEX array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is REAL",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is REAL",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to CLA_SYRFSX_EXTENDED had an illegal",
       "            value"]}},
 "dla_porfsx_extended"=>
  {"summary"=>
    ["DLA_PORFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by DPORFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by DPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension",
       "                   (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by DPOTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by DLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is DOUBLE PRECISION array, dimension (N)",
       "    Workspace. This can be the same workspace passed for Y_TAIL."],
     "DY"=>
      ["[in]",
       "         DY is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is DOUBLE PRECISION",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is DOUBLE PRECISION",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to DPOTRS had an illegal",
       "            value"]}},
 "cunm2l"=>
  {"summary"=>
    ["CUNM2L overwrites the general complex m-by-n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**H* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**H if SIDE = 'R' and TRANS = 'C',",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by CGEQLF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left",
       "         = 'R': apply Q or Q**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGEQLF in the last k columns of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGEQLF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "spocon"=>
  {"summary"=>
    ["SPOCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric positive definite matrix using the",
     "Cholesky factorization A = U**T*U or A = L*L**T computed by SPOTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, as computed by SPOTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm (or infinity-norm) of the symmetric matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slamtsqr"=>
  {"summary"=>
    ["     SLAMTSQR overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "     where Q is a real orthogonal matrix defined as the product",
     "     of blocked elementary reflectors computed by tall skinny",
     "     QR factorization (DLATSQR)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         N >= K >= 0;"],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.",
       "         MB > N. (must be the same as DLATSQR)"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         blockedelementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by DLATSQR in the first k columns of",
       "         its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension",
       "         ( N * Number of blocks(CEIL(M-K/MB-K)),",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]", "        (workspace) REAL array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N)*NB;",
       "         if SIDE = 'R', LWORK >= max(1,MB)*NB.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dtpmqrt"=>
  {"summary"=>
    ["DTPMQRT applies a real orthogonal matrix Q obtained from a",
     "\"triangular-pentagonal\" real block reflector H to a general",
     "real matrix C, which consists of two blocks A and B."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size used for the storage of T.  K >= NB >= 1.",
       "         This must be the same value of NB used to generate T",
       "         in CTPQRT."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CTPQRT in B.  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDV >= max(1,M);",
       "         if SIDE = 'R', LDV >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by CTPQRT, stored as a NB-by-K matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension",
       "         (LDA,N) if SIDE = 'L' or",
       "         (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         Q*C or Q**T*C or C*Q or C*Q**T.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         Q*C or Q**T*C or C*Q or C*Q**T.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array. The dimension of WORK is",
       "          N*NB if SIDE = 'L', or  M*NB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlarfg"=>
  {"summary"=>
    ["ZLARFG generates a complex elementary reflector H of order n, such",
     "that",
     "      H**H * ( alpha ) = ( beta ),   H**H * H = I.",
     "             (   x   )   (   0  )",
     "where alpha and beta are scalars, with beta real, and x is an",
     "(n-1)-element complex vector. H is represented in the form",
     "      H = I - tau * ( 1 ) * ( 1 v**H ) ,",
     "                    ( v )",
     "where tau is a complex scalar and v is a complex (n-1)-element",
     "vector. Note that H is not hermitian.",
     "If the elements of x are all zero and alpha is real, then tau = 0",
     "and H is taken to be the unit matrix.",
     "Otherwise  1 <= real(tau) <= 2  and  abs(tau-1) <= 1 ."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the elementary reflector."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is COMPLEX*16",
       "         On entry, the value alpha.",
       "         On exit, it is overwritten with the value beta."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension",
       "                        (1+(N-2)*abs(INCX))",
       "         On entry, the vector x.",
       "         On exit, it is overwritten with the vector v."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "TAU"=>
      ["[out]", "         TAU is COMPLEX*16", "         The value tau."]}},
 "zsytrf_aa"=>
  {"summary"=>
    ["ZSYTRF_AA computes the factorization of a complex symmetric matrix A",
     "using the Aasen's algorithm.  The form of the factorization is",
     "   A = U*T*U**T  or  A = L*T*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is a complex symmetric tridiagonal matrix.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the tridiagonal matrix is stored in the diagonals",
       "         and the subdiagonals of A just below (or above) the diagonals,",
       "         and L is stored below (or above) the subdiaonals, when UPLO",
       "         is 'L' (or 'U')."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK. LWORK >=MAX(1,2*N). For optimum performance",
       "         LWORK >= N*(1+NB), where NB is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "sggqrf"=>
  {"summary"=>
    ["SGGQRF computes a generalized QR factorization of an N-by-M matrix A",
     "and an N-by-P matrix B:",
     "            A = Q*R,        B = Q*T*Z,",
     "where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal",
     "matrix, and R and T assume one of the forms:",
     "if N >= M,  R = ( R11 ) M  ,   or if N < M,  R = ( R11  R12 ) N,",
     "                (  0  ) N-M                         N   M-N",
     "                   M",
     "where R11 is upper triangular, and",
     "if N <= P,  T = ( 0  T12 ) N,   or if N > P,  T = ( T11 ) N-P,",
     "                 P-N  N                           ( T21 ) P",
     "                                                     P",
     "where T12 or T21 is upper triangular.",
     "In particular, if B is square and nonsingular, the GQR factorization",
     "of A and B implicitly gives the QR factorization of inv(B)*A:",
     "             inv(B)*A = Z**T*(inv(T)*R)",
     "where inv(B) denotes the inverse of the matrix B, and Z**T denotes the",
     "transpose of the matrix Z."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrices A and B. N >= 0."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of columns of the matrix B.  P >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,M)",
       "         On entry, the N-by-M matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(N,M)-by-M upper trapezoidal matrix R (R is",
       "         upper triangular if N >= M); the elements below the diagonal,",
       "         with the array TAUA, represent the orthogonal matrix Q as a",
       "         product of min(N,M) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "TAUA"=>
      ["[out]",
       "         TAUA is REAL array, dimension (min(N,M))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Q (see Further Details)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,P)",
       "         On entry, the N-by-P matrix B.",
       "         On exit, if N <= P, the upper triangle of the subarray",
       "         B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T;",
       "         if N > P, the elements on and above the (N-P)-th subdiagonal",
       "         contain the N-by-P upper trapezoidal matrix T; the remaining",
       "         elements, with the array TAUB, represent the orthogonal",
       "         matrix Z as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "TAUB"=>
      ["[out]",
       "         TAUB is REAL array, dimension (min(N,P))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Z (see Further Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N,M,P).",
       "         For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),",
       "         where NB1 is the optimal blocksize for the QR factorization",
       "         of an N-by-M matrix, NB2 is the optimal blocksize for the",
       "         RQ factorization of an N-by-P matrix, and NB3 is the optimal",
       "         blocksize for a call of SORMQR.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zunmr3"=>
  {"summary"=>
    ["ZUNMR3 overwrites the general complex m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**H* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**H if SIDE = 'R' and TRANS = 'C',",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by ZTZRZF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left",
       "         = 'R': apply Q or Q**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing",
       "         the meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         ZTZRZF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZTZRZF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dgeqr2p"=>
  {"summary"=>
    ["DGEQR2P computes a QR factorization of a real m by n matrix A:",
     "A = Q * R. The diagonal entries of R are nonnegative."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(m,n) by n upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n). The diagonal entries of R are",
       "         nonnegative; the elements below the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zggrqf"=>
  {"summary"=>
    ["ZGGRQF computes a generalized RQ factorization of an M-by-N matrix A",
     "and a P-by-N matrix B:",
     "            A = R*Q,        B = Z*T*Q,",
     "where Q is an N-by-N unitary matrix, Z is a P-by-P unitary",
     "matrix, and R and T assume one of the forms:",
     "if M <= N,  R = ( 0  R12 ) M,   or if M > N,  R = ( R11 ) M-N,",
     "                 N-M  M                           ( R21 ) N",
     "                                                     N",
     "where R12 or R21 is upper triangular, and",
     "if P >= N,  T = ( T11 ) N  ,   or if P < N,  T = ( T11  T12 ) P,",
     "                (  0  ) P-N                         P   N-P",
     "                   N",
     "where T11 is upper triangular.",
     "In particular, if B is square and nonsingular, the GRQ factorization",
     "of A and B implicitly gives the RQ factorization of A*inv(B):",
     "             A*inv(B) = (R*inv(T))*Z**H",
     "where inv(B) denotes the inverse of the matrix B, and Z**H denotes the",
     "conjugate transpose of the matrix Z."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, if M <= N, the upper triangle of the subarray",
       "         A(1:M,N-M+1:N) contains the M-by-M upper triangular matrix R;",
       "         if M > N, the elements on and above the (M-N)-th subdiagonal",
       "         contain the M-by-N upper trapezoidal matrix R; the remaining",
       "         elements, with the array TAUA, represent the unitary",
       "         matrix Q as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "TAUA"=>
      ["[out]",
       "         TAUA is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Q (see Further Details)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(P,N)-by-N upper trapezoidal matrix T (T is",
       "         upper triangular if P >= N); the elements below the diagonal,",
       "         with the array TAUB, represent the unitary matrix Z as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TAUB"=>
      ["[out]",
       "         TAUB is COMPLEX*16 array, dimension (min(P,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Z (see Further Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N,M,P).",
       "         For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),",
       "         where NB1 is the optimal blocksize for the RQ factorization",
       "         of an M-by-N matrix, NB2 is the optimal blocksize for the",
       "         QR factorization of a P-by-N matrix, and NB3 is the optimal",
       "         blocksize for a call of ZUNMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO=-i, the i-th argument had an illegal value."]}},
 "zsycon_3"=>
  {"summary"=>
    ["ZSYCON_3 estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex symmetric matrix A using the factorization",
     "computed by ZSYTRF_RK or ZSYTRF_BK:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).",
     "This routine uses BLAS3 solver ZSYTRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**T)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**T)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by ZSYTRF_RK and ZSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF_RK or ZSYTRF_BK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgbtrs"=>
  {"summary"=>
    ["ZGBTRS solves a system of linear equations",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B",
     "with a general band matrix A using the LU factorization computed",
     "by ZGBTRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations.",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by ZGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= N, row i of the matrix was",
       "         interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sspgvd"=>
  {"summary"=>
    ["SSPGVD computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be symmetric, stored in packed format, and B is also",
     "positive definite.",
     "If eigenvectors are desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T, in the same storage",
       "         format as B."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors.  The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the required LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LWORK >= 2*N.",
       "         If JOBZ = 'V' and N > 1, LWORK >= 1 + 6*N + 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the required sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the required LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK >= 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  SPPTRF or SSPEVD returned an error code:",
       "            <= N:  if INFO = i, SSPEVD failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "dlauu2"=>
  {"summary"=>
    ["DLAUU2 computes the product U * U**T or L**T * L, where the triangular",
     "factor U or L is stored in the upper or lower triangular part of",
     "the array A.",
     "If UPLO = 'U' or 'u' then the upper triangle of the result is stored,",
     "overwriting the factor U in A.",
     "If UPLO = 'L' or 'l' then the lower triangle of the result is stored,",
     "overwriting the factor L in A.",
     "This is the unblocked form of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the triangular factor stored in the array A",
       "         is upper or lower triangular:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the triangular factor U or L.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L.",
       "         On exit, if UPLO = 'U', the upper triangle of A is",
       "         overwritten with the upper triangle of the product U * U**T;",
       "         if UPLO = 'L', the lower triangle of A is overwritten with",
       "         the lower triangle of the product L**T * L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "dgbtrf"=>
  {"summary"=>
    ["DGBTRF computes an LU factorization of a real m-by-n band matrix A",
     "using partial pivoting with row interchanges.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(kl+ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = +i, U(i,i) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "ssb2st_kernels"=>
  {"summary"=>
    ["SSB2ST_KERNELS is an internal routine used by the SSYTRD_SB2ST",
     "subroutine."],
   "param"=>nil},
 "cunmbr"=>
  {"summary"=>
    ["If VECT = 'Q', CUNMBR overwrites the general complex M-by-N matrix C",
     "with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "If VECT = 'P', CUNMBR overwrites the general complex M-by-N matrix C",
     "with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      P * C          C * P",
     "TRANS = 'C':      P**H * C       C * P**H",
     "Here Q and P**H are the unitary matrices determined by CGEBRD when",
     "reducing a complex matrix A to bidiagonal form: A = Q * B * P**H. Q",
     "and P**H are defined as products of elementary reflectors H(i) and",
     "G(i) respectively.",
     "Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the",
     "order of the unitary matrix Q or P**H that is applied.",
     "If VECT = 'Q', A is assumed to have been an NQ-by-K matrix:",
     "if nq >= k, Q = H(1) H(2) . . . H(k);",
     "if nq < k, Q = H(1) H(2) . . . H(nq-1).",
     "If VECT = 'P', A is assumed to have been a K-by-NQ matrix:",
     "if k < nq, P = G(1) G(2) . . . G(k);",
     "if k >= nq, P = G(1) G(2) . . . G(nq-1)."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'Q': apply Q or Q**H;",
       "         = 'P': apply P or P**H."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q, Q**H, P or P**H from the Left;",
       "         = 'R': apply Q, Q**H, P or P**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q or P;",
       "         = 'C':  Conjugate transpose, apply Q**H or P**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         If VECT = 'Q', the number of columns in the original",
       "         matrix reduced by CGEBRD.",
       "         If VECT = 'P', the number of rows in the original",
       "         matrix reduced by CGEBRD.",
       "         K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension",
       "                               (LDA,min(nq,K)) if VECT = 'Q'",
       "                               (LDA,nq)        if VECT = 'P'",
       "         The vectors which define the elementary reflectors H(i) and",
       "         G(i), whose products determine the matrices Q and P, as",
       "         returned by CGEBRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If VECT = 'Q', LDA >= max(1,nq);",
       "         if VECT = 'P', LDA >= max(1,min(nq,K))."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (min(nq,K))",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i) or G(i) which determines Q or P, as returned",
       "         by CGEBRD in the array argument TAUQ or TAUP."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q",
       "         or P*C or P**H*C or C*P or C*P**H."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M);",
       "         if N = 0 or M = 0, LWORK >= 1.",
       "         For optimum performance LWORK >= max(1,N*NB) if SIDE = 'L',",
       "         and LWORK >= max(1,M*NB) if SIDE = 'R', where NB is the",
       "         optimal blocksize. (NB = 0 if M = 0 or N = 0.)",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chptrd"=>
  {"summary"=>
    ["CHPTRD reduces a complex Hermitian matrix A stored in packed form to",
     "real symmetric tridiagonal form T by a unitary similarity",
     "transformation: Q**H * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the unitary",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the unitary matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chbtrd"=>
  {"summary"=>
    ["CHBTRD reduces a complex Hermitian band matrix A to real symmetric",
     "tridiagonal form T by a unitary similarity transformation:",
     "Q**H * A * Q = T."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  do not form Q;",
       "         = 'V':  form Q;",
       "         = 'U':  update a matrix X, by forming X*Q."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, the diagonal elements of AB are overwritten by the",
       "         diagonal elements of the tridiagonal matrix T; if KD > 0, the",
       "         elements on the first superdiagonal (if UPLO = 'U') or the",
       "         first subdiagonal (if UPLO = 'L') are overwritten by the",
       "         off-diagonal elements of T; the rest of AB is overwritten by",
       "         values generated during the reduction."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = T(i,i+1) if UPLO = 'U'; E(i) = T(i+1,i) if UPLO = 'L'."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX array, dimension (LDQ,N)",
       "         On entry, if VECT = 'U', then Q must contain an N-by-N",
       "         matrix X; if VECT = 'N' or 'V', then Q need not be set.",
       "         On exit:",
       "         if VECT = 'V', Q contains the N-by-N unitary matrix Q;",
       "         if VECT = 'U', Q contains the product X*Q;",
       "         if VECT = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= 1, and LDQ >= N if VECT = 'V' or 'U'."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dggsvd3"=>
  {"summary"=>
    ["DGGSVD3 computes the generalized singular value decomposition (GSVD)",
     "of an M-by-N real matrix A and P-by-N real matrix B:",
     "      U**T*A*Q = D1*( 0 R ),    V**T*B*Q = D2*( 0 R )",
     "where U, V and Q are orthogonal matrices.",
     "Let K+L = the effective numerical rank of the matrix (A**T,B**T)**T,",
     "then R is a K+L-by-K+L nonsingular upper triangular matrix, D1 and",
     "D2 are M-by-(K+L) and P-by-(K+L) \"diagonal\" matrices and of the",
     "following structures, respectively:",
     "If M-K-L >= 0,",
     "                    K  L",
     "       D1 =     K ( I  0 )",
     "                L ( 0  C )",
     "            M-K-L ( 0  0 )",
     "                  K  L",
     "       D2 =   L ( 0  S )",
     "            P-L ( 0  0 )",
     "                N-K-L  K    L",
     "  ( 0 R ) = K (  0   R11  R12 )",
     "            L (  0    0   R22 )",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(K+L) ),",
     "  S = diag( BETA(K+1),  ... , BETA(K+L) ),",
     "  C**2 + S**2 = I.",
     "  R is stored in A(1:K+L,N-K-L+1:N) on exit.",
     "If M-K-L < 0,",
     "                  K M-K K+L-M",
     "       D1 =   K ( I  0    0   )",
     "            M-K ( 0  C    0   )",
     "                    K M-K K+L-M",
     "       D2 =   M-K ( 0  S    0  )",
     "            K+L-M ( 0  0    I  )",
     "              P-L ( 0  0    0  )",
     "                   N-K-L  K   M-K  K+L-M",
     "  ( 0 R ) =     K ( 0    R11  R12  R13  )",
     "              M-K ( 0     0   R22  R23  )",
     "            K+L-M ( 0     0    0   R33  )",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(M) ),",
     "  S = diag( BETA(K+1),  ... , BETA(M) ),",
     "  C**2 + S**2 = I.",
     "  (R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N), and R33 is stored",
     "  ( 0  R22 R23 )",
     "  in B(M-K+1:L,N+M-K-L+1:N) on exit.",
     "The routine computes C, S, R, and optionally the orthogonal",
     "transformation matrices U, V and Q.",
     "In particular, if B is an N-by-N nonsingular matrix, then the GSVD of",
     "A and B implicitly gives the SVD of A*inv(B):",
     "                     A*inv(B) = U*(D1*inv(D2))*V**T.",
     "If ( A**T,B**T)**T  has orthonormal columns, then the GSVD of A and B is",
     "also equal to the CS decomposition of A and B. Furthermore, the GSVD",
     "can be used to derive the solution of the eigenvalue problem:",
     "                     A**T*A x = lambda* B**T*B x.",
     "In some literature, the GSVD of A and B is presented in the form",
     "                 U**T*A*X = ( 0 D1 ),   V**T*B*X = ( 0 D2 )",
     "where U and V are orthogonal and X is nonsingular, D1 and D2 are",
     "``diagonal''.  The former GSVD form can be converted to the latter",
     "form by taking the nonsingular matrix X as",
     "                     X = Q*( I   0    )",
     "                           ( 0 inv(R) )."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  Orthogonal matrix U is computed;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  Orthogonal matrix V is computed;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Orthogonal matrix Q is computed;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "K"=>["[out]", "         K is INTEGER"],
     "L"=>
      ["[out]",
       "         L is INTEGER",
       "         On exit, K and L specify the dimension of the subblocks",
       "         described in Purpose.",
       "         K + L = effective numerical rank of (A**T,B**T)**T."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A contains the triangular matrix R, or part of R.",
       "         See Purpose for details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, B contains the triangular matrix R if M-K-L < 0.",
       "         See Purpose for details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "ALPHA"=>
      ["[out]", "         ALPHA is DOUBLE PRECISION array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         On exit, ALPHA and BETA contain the generalized singular",
       "         value pairs of A and B;",
       "           ALPHA(1:K) = 1,",
       "           BETA(1:K)  = 0,",
       "         and if M-K-L >= 0,",
       "           ALPHA(K+1:K+L) = C,",
       "           BETA(K+1:K+L)  = S,",
       "         or if M-K-L < 0,",
       "           ALPHA(K+1:M)=C, ALPHA(M+1:K+L)=0",
       "           BETA(K+1:M) =S, BETA(M+1:K+L) =1",
       "         and",
       "           ALPHA(K+L+1:N) = 0",
       "           BETA(K+L+1:N)  = 0"],
     "U"=>
      ["[out]",
       "         U is DOUBLE PRECISION array, dimension (LDU,M)",
       "         If JOBU = 'U', U contains the M-by-M orthogonal matrix U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[out]",
       "         V is DOUBLE PRECISION array, dimension (LDV,P)",
       "         If JOBV = 'V', V contains the P-by-P orthogonal matrix V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         If JOBQ = 'Q', Q contains the N-by-N orthogonal matrix Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N)",
       "         On exit, IWORK stores the sorting information. More",
       "         precisely, the following loop will sort ALPHA",
       "            for I = K+1, min(M,K+L)",
       "                swap ALPHA(I) and ALPHA(IWORK(I))",
       "            endfor",
       "         such that ALPHA(1) >= ALPHA(2) >= ... >= ALPHA(N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, the Jacobi-type procedure failed to",
       "               converge.  For further details, see subroutine DTGSJA."]}},
 "cpotrs"=>
  {"summary"=>
    ["CPOTRS solves a system of linear equations A*X = B with a Hermitian",
     "positive definite matrix A using the Cholesky factorization",
     "A = U**H*U or A = L*L**H computed by CPOTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H, as computed by CPOTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dtpcon"=>
  {"summary"=>
    ["DTPCON estimates the reciprocal of the condition number of a packed",
     "triangular matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clasyf_aa"=>
  {"summary"=>
    ["DLATRF_AA factorizes a panel of a complex symmetric matrix A using",
     "the Aasen's algorithm. The panel consists of a set of NB rows of A",
     "when UPLO is U, or a set of NB columns when UPLO is L.",
     "In order to factorize the panel, the Aasen's algorithm requires the",
     "last row, or column, of the previous panel. The first row, or column,",
     "of A is set to be the first row, or column, of an identity matrix,",
     "which is used to factorize the first panel.",
     "The resulting J-th row of U, or J-th column of L, is stored in the",
     "(J-1)-th row, or column, of A (without the unit diagonals), while",
     "the diagonal and subdiagonal of A are overwritten by those of T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The location of the first row, or column, of the panel",
       "         within the submatrix of A, passed to this routine, e.g.,",
       "         when called by CSYTRF_AA, for the first panel, J1 is 1,",
       "         while for the remaining panels, J1 is 2."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The dimension of the submatrix. M >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The dimension of the panel to be facotorized."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,M) for",
       "         the first panel, while dimension (LDA,M+1) for the",
       "         remaining panels.",
       "         On entry, A contains the last row, or column, of",
       "         the previous panel, and the trailing submatrix of A",
       "         to be factorized, except for the first panel, only",
       "         the panel is passed.",
       "         On exit, the leading panel is factorized."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the row and column interchanges,",
       "         the row and column k were interchanged with the row and",
       "         column IPIV(k)."],
     "H"=>["[in,out]", "         H is REAL workspace, dimension (LDH,NB)."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the workspace H. LDH >= max(1,M)."],
     "WORK"=>["[out]", "         WORK is REAL workspace, dimension (M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "dtrttp"=>
  {"summary"=>
    ["DTRTTP copies a triangular matrix A from full format (TR) to standard",
     "packed format (TP)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular.",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices AP and A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On exit, the triangular matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AP"=>
      ["[out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2",
       "         On exit, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slaev2"=>
  {"summary"=>
    ["SLAEV2 computes the eigendecomposition of a 2-by-2 symmetric matrix",
     "   [  A   B  ]",
     "   [  B   C  ].",
     "On return, RT1 is the eigenvalue of larger absolute value, RT2 is the",
     "eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right",
     "eigenvector for RT1, giving the decomposition",
     "   [ CS1  SN1 ] [  A   B  ] [ CS1 -SN1 ]  =  [ RT1  0  ]",
     "   [-SN1  CS1 ] [  B   C  ] [ SN1  CS1 ]     [  0  RT2 ]."],
   "param"=>
    {"A"=>
      ["[in]",
       "         A is REAL",
       "         The (1,1) element of the 2-by-2 matrix."],
     "B"=>
      ["[in]",
       "         B is REAL",
       "         The (1,2) element and the conjugate of the (2,1) element of",
       "         the 2-by-2 matrix."],
     "C"=>
      ["[in]",
       "         C is REAL",
       "         The (2,2) element of the 2-by-2 matrix."],
     "RT1"=>
      ["[out]",
       "         RT1 is REAL",
       "         The eigenvalue of larger absolute value."],
     "RT2"=>
      ["[out]",
       "         RT2 is REAL",
       "         The eigenvalue of smaller absolute value."],
     "CS1"=>["[out]", "         CS1 is REAL"],
     "SN1"=>
      ["[out]",
       "         SN1 is REAL",
       "         The vector (CS1, SN1) is a unit right eigenvector for RT1."]}},
 "csycon_3"=>
  {"summary"=>
    ["CSYCON_3 estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex symmetric matrix A using the factorization",
     "computed by CSYTRF_RK or CSYTRF_BK:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).",
     "This routine uses BLAS3 solver CSYTRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**T)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**T)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by CSYTRF_RK and CSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF_RK or CSYTRF_BK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaqtr"=>
  {"summary"=>
    ["DLAQTR solves the real quasi-triangular system",
     "             op(T)*p = scale*c,               if LREAL = .TRUE.",
     "or the complex quasi-triangular systems",
     "           op(T + iB)*(p+iq) = scale*(c+id),  if LREAL = .FALSE.",
     "in real arithmetic, where T is upper quasi-triangular.",
     "If LREAL = .FALSE., then the first diagonal block of T must be",
     "1 by 1, B is the specially structured matrix",
     "               B = [ b(1) b(2) ... b(n) ]",
     "                   [       w            ]",
     "                   [           w        ]",
     "                   [              .     ]",
     "                   [                 w  ]",
     "op(A) = A or A**T, A**T denotes the transpose of",
     "matrix A.",
     "On input, X = [ c ].  On output, X = [ p ].",
     "              [ d ]                  [ q ]",
     "This subroutine is designed for the condition number estimation",
     "in routine DTRSNA."],
   "param"=>
    {"LTRAN"=>
      ["[in]",
       "         LTRAN is LOGICAL",
       "         On entry, LTRAN specifies the option of conjugate transpose:",
       "            = .FALSE.,    op(T+i*B) = T+i*B,",
       "            = .TRUE.,     op(T+i*B) = (T+i*B)**T."],
     "LREAL"=>
      ["[in]",
       "         LREAL is LOGICAL",
       "         On entry, LREAL specifies the input matrix structure:",
       "            = .FALSE.,    the input is complex",
       "            = .TRUE.,     the input is real"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         On entry, N specifies the order of T+i*B. N >= 0."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         On entry, T contains a matrix in Schur canonical form.",
       "         If LREAL = .FALSE., then the first diagonal block of T mu",
       "         be 1 by 1."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the matrix T. LDT >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (N)",
       "         On entry, B contains the elements to form the matrix",
       "         B as described above.",
       "         If LREAL = .TRUE., B is not referenced."],
     "W"=>
      ["[in]",
       "         W is DOUBLE PRECISION",
       "         On entry, W is the diagonal element of the matrix B.",
       "         If LREAL = .TRUE., W is not referenced."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         On exit, SCALE is the scale factor."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (2*N)",
       "         On entry, X contains the right hand side of the system.",
       "         On exit, X is overwritten by the solution."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO is set to",
       "            0: successful exit.",
       "              1: the some diagonal 1 by 1 block has been perturbed by",
       "                 a small number SMIN to keep nonsingularity.",
       "              2: the some diagonal 2 by 2 block has been perturbed by",
       "                 a small number in DLALN2 to keep nonsingularity.",
       "         NOTE: In the interests of speed, this routine does not",
       "               check the inputs for errors."]}},
 "sormrz"=>
  {"summary"=>
    ["SORMRZ overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by STZRZF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing",
       "         the meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         STZRZF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by STZRZF."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cspsv"=>
  {"summary"=>
    ["CSPSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix stored in packed format and X",
     "and B are N-by-NRHS matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, D is symmetric and block diagonal with 1-by-1",
     "and 2-by-2 diagonal blocks.  The factored form of A is then used to",
     "solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L from the factorization",
       "         A = U*D*U**T or A = L*D*L**T as computed by CSPTRF, stored as",
       "         a packed triangular matrix in the same storage format as A."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by CSPTRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, so the solution could not be",
       "               computed."]}},
 "zunglq"=>
  {"summary"=>
    ["ZUNGLQ generates an M-by-N complex matrix Q with orthonormal rows,",
     "which is defined as the first M rows of a product of K elementary",
     "reflectors of order N",
     "      Q  =  H(k)**H . . . H(2)**H H(1)**H",
     "as returned by ZGELQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the i-th row must contain the vector which defines",
       "         the elementary reflector H(i), for i = 1,2,...,k, as returned",
       "         by ZGELQF in the first k rows of its array argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGELQF."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit;",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "zlansy"=>
  {"summary"=>
    ["ZLANSY  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex symmetric matrix A.",
     "   ZLANSY = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANSY as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is to be referenced.",
       "         = 'U':  Upper triangular part of A is referenced",
       "         = 'L':  Lower triangular part of A is referenced"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANSY is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The symmetric matrix A.  If UPLO = 'U', the leading n by n",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading n by n lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "cgetrf"=>
  {"summary"=>
    ["CGETRF computes an LU factorization of a general M-by-N matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the right-looking Level 3 BLAS version of the algorithm."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "dgeequ"=>
  {"summary"=>
    ["DGEEQU computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.",
     "R(i) and C(j) are restricted to be between SMLNUM = smallest safe",
     "number and BIGNUM = largest safe number.  Use of these scaling",
     "factors is not guaranteed to reduce the condition number of A but",
     "works well in practice."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The M-by-N matrix whose equilibration factors are",
       "         to be computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is DOUBLE PRECISION",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is DOUBLE PRECISION",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "zlaqhp"=>
  {"summary"=>
    ["ZLAQHP equilibrates a Hermitian matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the equilibrated matrix:  diag(S) * A * diag(S), in",
       "         the same storage format as A."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is DOUBLE PRECISION",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "cla_gbrcond_x"=>
  {"summary"=>
    ["   CLA_GBRCOND_X Computes the infinity norm condition number of",
     "   op(A) * diag(X) where X is a COMPLEX vector."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "    On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by CGBTRF.  U is stored as an upper triangular",
       "    band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1,",
       "    and the multipliers used during the factorization are stored",
       "    in rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by CGBTRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension (N)",
       "    The vector X in the formula op(A) * diag(X)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is REAL array, dimension (N).",
       "    Workspace."]}},
 "zspsv"=>
  {"summary"=>
    ["ZSPSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix stored in packed format and X",
     "and B are N-by-NRHS matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, D is symmetric and block diagonal with 1-by-1",
     "and 2-by-2 diagonal blocks.  The factored form of A is then used to",
     "solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L from the factorization",
       "         A = U*D*U**T or A = L*D*L**T as computed by ZSPTRF, stored as",
       "         a packed triangular matrix in the same storage format as A."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by ZSPTRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, so the solution could not be",
       "               computed."]}},
 "dgeqrt"=>
  {"summary"=>
    ["DGEQRT computes a blocked QR factorization of a real M-by-N matrix A",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.  MIN(M,N) >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if M >= N); the elements below the diagonal",
       "         are the columns of V."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,MIN(M,N))",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (NB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgtsv"=>
  {"summary"=>
    ["CGTSV  solves the equation",
     "   A*X = B,",
     "where A is an N-by-N tridiagonal matrix, by Gaussian elimination with",
     "partial pivoting.",
     "Note that the equation  A**T *X = B  may be solved by interchanging the",
     "order of the arguments DU and DL."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in,out]",
       "         DL is COMPLEX array, dimension (N-1)",
       "         On entry, DL must contain the (n-1) subdiagonal elements of",
       "         A.",
       "         On exit, DL is overwritten by the (n-2) elements of the",
       "         second superdiagonal of the upper triangular matrix U from",
       "         the LU factorization of A, in DL(1), ..., DL(n-2)."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX array, dimension (N)",
       "         On entry, D must contain the diagonal elements of A.",
       "         On exit, D is overwritten by the n diagonal elements of U."],
     "DU"=>
      ["[in,out]",
       "         DU is COMPLEX array, dimension (N-1)",
       "         On entry, DU must contain the (n-1) superdiagonal elements",
       "         of A.",
       "         On exit, DU is overwritten by the (n-1) elements of the first",
       "         superdiagonal of U."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero, and the solution",
       "               has not been computed.  The factorization has not been",
       "               completed unless i = N."]}},
 "zlaed7"=>
  {"summary"=>
    ["ZLAED7 computes the updated eigensystem of a diagonal",
     "matrix after modification by a rank-one symmetric matrix. This",
     "routine is used only for the eigenproblem which requires all",
     "eigenvalues and optionally eigenvectors of a dense or banded",
     "Hermitian matrix that has been reduced to tridiagonal form.",
     "  T = Q(in) ( D(in) + RHO * Z*Z**H ) Q**H(in) = Q(out) * D(out) * Q**H(out)",
     "  where Z = Q**Hu, u is a vector of length N with ones in the",
     "  CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.",
     "   The eigenvectors of the original matrix are stored in Q, and the",
     "   eigenvalues are in D.  The algorithm consists of three stages:",
     "      The first stage consists of deflating the size of the problem",
     "      when there are multiple eigenvalues or if there is a zero in",
     "      the Z vector.  For each such occurrence the dimension of the",
     "      secular equation problem is reduced by one.  This stage is",
     "      performed by the routine DLAED2.",
     "      The second stage consists of calculating the updated",
     "      eigenvalues. This is done by finding the roots of the secular",
     "      equation via the routine DLAED4 (as called by SLAED3).",
     "      This routine also calculates the eigenvectors of the current",
     "      problem.",
     "      The final stage consists of computing the updated eigenvectors",
     "      directly using the updated eigenvalues.  The eigenvectors for",
     "      the current problem are multiplied with the eigenvectors from",
     "      the overall problem."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "CUTPNT"=>
      ["[in]",
       "         CUTPNT is INTEGER",
       "        Contains the location of the last eigenvalue in the leading",
       "        sub-matrix.  min(1,N) <= CUTPNT <= N."],
     "QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the unitary matrix used to reduce",
       "        the full matrix to tridiagonal form.  QSIZ >= N."],
     "TLVLS"=>
      ["[in]",
       "         TLVLS is INTEGER",
       "        The total number of merging levels in the overall divide and",
       "        conquer tree."],
     "CURLVL"=>
      ["[in]",
       "         CURLVL is INTEGER",
       "        The current level in the overall merge routine,",
       "        0 <= curlvl <= tlvls."],
     "CURPBM"=>
      ["[in]",
       "         CURPBM is INTEGER",
       "        The current problem in the current level in the overall",
       "        merge routine (counting from upper left to lower right)."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        On entry, the eigenvalues of the rank-1-perturbed matrix.",
       "        On exit, the eigenvalues of the repaired matrix."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,N)",
       "        On entry, the eigenvectors of the rank-1-perturbed matrix.",
       "        On exit, the eigenvectors of the repaired tridiagonal matrix."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "RHO"=>
      ["[in]",
       "         RHO is DOUBLE PRECISION",
       "        Contains the subdiagonal element used to create the rank-1",
       "        modification."],
     "INDXQ"=>
      ["[out]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        This contains the permutation which will reintegrate the",
       "        subproblem just solved back into sorted order,",
       "        ie. D( INDXQ( I = 1, N ) ) will be in ascending order."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (4*N)"],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array,",
       "                                dimension (3*N+2*QSIZ*N)"],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX*16 array, dimension (QSIZ*N)"],
     "QSTORE"=>
      ["[in,out]",
       "         QSTORE is DOUBLE PRECISION array, dimension (N**2+1)",
       "        Stores eigenvectors of submatrices encountered during",
       "        divide and conquer, packed together. QPTR points to",
       "        beginning of the submatrices."],
     "QPTR"=>
      ["[in,out]",
       "         QPTR is INTEGER array, dimension (N+2)",
       "        List of indices pointing to beginning of submatrices stored",
       "        in QSTORE. The submatrices are numbered starting at the",
       "        bottom left of the divide and conquer tree, from left to",
       "        right and bottom to top."],
     "PRMPTR"=>
      ["[in]",
       "         PRMPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in PERM a",
       "        level's permutation is stored.  PRMPTR(i+1) - PRMPTR(i)",
       "        indicates the size of the permutation and also the size of",
       "        the full, non-deflated problem."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension (N lg N)",
       "        Contains the permutations (from deflation and sorting) to be",
       "        applied to each eigenblock."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER array, dimension (N lg N)",
       "        Contains a list of pointers which indicate where in GIVCOL a",
       "        level's Givens rotations are stored.  GIVPTR(i+1) - GIVPTR(i)",
       "        indicates the number of Givens rotations."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension (2, N lg N)",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is DOUBLE PRECISION array, dimension (2, N lg N)",
       "        Each number indicates the S value to be used in the",
       "        corresponding Givens rotation."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, an eigenvalue did not converge"]}},
 "sgemlq"=>
  {"summary"=>
    ["    SGEMLQ overwrites the general real M-by-N matrix C with",
     "                   SIDE = 'L'     SIDE = 'R'",
     "   TRANS = 'N':      Q * C          C * Q",
     "   TRANS = 'T':      Q**T * C       C * Q**T",
     "   where Q is a real orthogonal matrix defined as the product",
     "   of blocked elementary reflectors computed by short wide LQ",
     "   factorization (SGELQ)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         Part of the data structure to represent Q as returned by DGELQ."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (MAX(5,TSIZE)).",
       "         Part of the data structure to represent Q as returned by SGELQ."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         The dimension of the array T. TSIZE >= 5."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]", "        (workspace) REAL array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed. The routine",
       "         only calculates the size of the WORK array, returns this",
       "         value as WORK(1), and no error message related to WORK ",
       "         is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "stzrzf"=>
  {"summary"=>
    ["STZRZF reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A",
     "to upper triangular form by means of orthogonal transformations.",
     "The upper trapezoidal matrix A is factored as",
     "   A = ( R  0 ) * Z,",
     "where Z is an N-by-N orthogonal matrix and R is an M-by-M upper",
     "triangular matrix."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= M."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the leading M-by-N upper trapezoidal part of the",
       "         array A must contain the matrix to be factorized.",
       "         On exit, the leading M-by-M upper triangular part of A",
       "         contains the upper triangular matrix R, and elements M+1 to",
       "         N of the first M rows of A, with the array TAU, represent the",
       "         orthogonal matrix Z as a product of M elementary reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (M)",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slaset"=>
  {"summary"=>
    ["SLASET initializes an m-by-n matrix A to BETA on the diagonal and",
     "ALPHA on the offdiagonals."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the part of the matrix A to be set.",
       "         = 'U':      Upper triangular part is set; the strictly lower",
       "                     triangular part of A is not changed.",
       "         = 'L':      Lower triangular part is set; the strictly upper",
       "                     triangular part of A is not changed.",
       "         Otherwise:  All of the matrix A is set."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "         The constant to which the offdiagonal elements are to be set."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL",
       "         The constant to which the diagonal elements are to be set."],
     "A"=>
      ["[out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On exit, the leading m-by-n submatrix of A is set as follows:",
       "         if UPLO = 'U', A(i,j) = ALPHA, 1<=i<=j-1, 1<=j<=n,",
       "         if UPLO = 'L', A(i,j) = ALPHA, j+1<=i<=m, 1<=j<=n,",
       "         otherwise,     A(i,j) = ALPHA, 1<=i<=m, 1<=j<=n, i.ne.j,",
       "         and, for all UPLO, A(i,i) = BETA, 1<=i<=min(m,n)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."]}},
 "spbtrs"=>
  {"summary"=>
    ["SPBTRS solves a system of linear equations A*X = B with a symmetric",
     "positive definite band matrix A using the Cholesky factorization",
     "A = U**T*U or A = L*L**T computed by SPBTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor stored in AB;",
       "         = 'L':  Lower triangular factor stored in AB."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T of the band matrix A, stored in the",
       "         first KD+1 rows of the array.  The j-th column of U or L is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO ='U', AB(kd+1+i-j,j) = U(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO ='L', AB(1+i-j,j)    = L(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgetc2"=>
  {"summary"=>
    ["DGETC2 computes an LU factorization with complete pivoting of the",
     "n-by-n matrix A. The factorization has the form A = P * L * U * Q,",
     "where P and Q are permutation matrices, L is lower triangular with",
     "unit diagonal elements and U is upper triangular.",
     "This is the Level 2 BLAS algorithm."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the n-by-n matrix A to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U*Q; the unit diagonal elements of L are not stored.",
       "         If U(k, k) appears to be less than SMIN, U(k, k) is given the",
       "         value of SMIN, i.e., giving a nonsingular perturbed system."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension(N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[out]",
       "         JPIV is INTEGER array, dimension(N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0: successful exit",
       "          > 0: if INFO = k, U(k, k) is likely to produce owerflow if",
       "               we try to solve for x in Ax = b. So U is perturbed to",
       "               avoid the overflow."]}},
 "dtpqrt"=>
  {"summary"=>
    ["DTPQRT computes a blocked QR factorization of a real",
     "\"triangular-pentagonal\" matrix C, which is composed of a",
     "triangular block A and pentagonal block B, using the compact",
     "WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of the",
       "         triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the upper trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.  N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the upper triangular N-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first M-L rows",
       "         are rectangular, and the last L rows are upper trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (NB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlaqsb"=>
  {"summary"=>
    ["ZLAQSB equilibrates a symmetric band matrix A using the scaling",
     "factors in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H *U or A = L*L**H of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is DOUBLE PRECISION",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "ilaclr"=>
  {"summary"=>["ILACLR scans A for its last non-zero row."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in]",
       "         A is array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."]}},
 "sppsvx"=>
  {"summary"=>
    ["SPPSVX uses the Cholesky factorization A = U**T*U or A = L*L**T to",
     "compute the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite matrix stored in",
     "packed format and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "dsysv_rk"=>
  {"summary"=>
    ["DSYSV_RK computes the solution to a real system of linear",
     "equations A * X = B, where A is an N-by-N symmetric matrix",
     "and X and B are N-by-NRHS matrices.",
     "The bounded Bunch-Kaufman (rook) diagonal pivoting method is used",
     "to factor A as",
     "   A = P*U*D*(U**T)*(P**T),  if UPLO = 'U', or",
     "   A = P*L*D*(L**T)*(P**T),  if UPLO = 'L',",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "DSYTRF_RK is called to compute the factorization of a real",
     "symmetric matrix.  The factored form of A is then used to solve",
     "the system of equations A * X = B by calling BLAS3 routine DSYTRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, if INFO = 0, diagonal of the block diagonal",
       "         matrix D and factors U or L  as computed by DSYTRF_RK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         For more info see the description of DSYTRF_RK routine."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On exit, contains the output computed by the factorization",
       "         routine DSYTRF_RK, i.e. the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases.",
       "         For more info see the description of DSYTRF_RK routine."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D,",
       "         as determined by DSYTRF_RK.",
       "         For more info see the description of DSYTRF_RK routine."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension ( MAX(1,LWORK) ).",
       "         Work array used in the factorization stage.",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1. For best performance",
       "         of factorization stage LWORK >= max(1,N*NB), where NB is",
       "         the optimal blocksize for DSYTRF_RK.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array for factorization stage, returns this value as",
       "         the first entry of the WORK array, and no error message",
       "         related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "dsbevd_2stage"=>
  {"summary"=>
    ["DSBEVD_2STAGE computes all the eigenvalues and, optionally, eigenvectors of",
     "a real symmetric band matrix A using the 2stage technique for",
     "the reduction to tridiagonal. If eigenvectors are desired, it uses",
     "a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension LWORK",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS + N",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 2, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "cungql"=>
  {"summary"=>
    ["CUNGQL generates an M-by-N complex matrix Q with orthonormal columns,",
     "which is defined as the last N columns of a product of K elementary",
     "reflectors of order M",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by CGEQLF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the (n-k+i)-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by CGEQLF in the last k columns of its array",
       "         argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGEQLF."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "zlat2c"=>
  {"summary"=>
    ["ZLAT2C converts a COMPLEX*16 triangular matrix, SA, to a COMPLEX",
     "triangular matrix, A.",
     "RMAX is the overflow for the SINGLE PRECISION arithmetic",
     "ZLAT2C checks that all the entries of A are between -RMAX and",
     "RMAX. If not the conversion is aborted and a flag is raised.",
     "This is an auxiliary routine so there is no argument checking."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows and columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the N-by-N triangular coefficient matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "SA"=>
      ["[out]",
       "         SA is COMPLEX array, dimension (LDSA,N)",
       "         Only the UPLO part of SA is referenced.  On exit, if INFO=0,",
       "         the N-by-N coefficient matrix SA; if INFO>0, the content of",
       "         the UPLO part of SA is unspecified."],
     "LDSA"=>
      ["[in]",
       "         LDSA is INTEGER",
       "         The leading dimension of the array SA.  LDSA >= max(1,M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         = 1:  an entry of the matrix A is greater than the SINGLE",
       "               PRECISION overflow threshold, in this case, the content",
       "               of the UPLO part of SA in exit is unspecified."]}},
 "zgghd3"=>
  {"summary"=>
    ["ZGGHD3 reduces a pair of complex matrices (A,B) to generalized upper",
     "Hessenberg form using unitary transformations, where A is a",
     "general matrix and B is upper triangular.  The form of the",
     "generalized eigenvalue problem is",
     "   A*x = lambda*B*x,",
     "and B is typically made upper triangular by computing its QR",
     "factorization and moving the unitary matrix Q to the left side",
     "of the equation.",
     "This subroutine simultaneously reduces A to a Hessenberg matrix H:",
     "   Q**H*A*Z = H",
     "and transforms B to another upper triangular matrix T:",
     "   Q**H*B*Z = T",
     "in order to reduce the problem to its standard form",
     "   H*y = lambda*T*y",
     "where y = Z**H*x.",
     "The unitary matrices Q and Z are determined as products of Givens",
     "rotations.  They may either be formed explicitly, or they may be",
     "postmultiplied into input matrices Q1 and Z1, so that",
     "     Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H",
     "     Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H",
     "If Q1 is the unitary matrix from the QR factorization of B in the",
     "original equation A*x = lambda*B*x, then ZGGHD3 reduces the original",
     "problem to generalized Hessenberg form.",
     "This is a blocked variant of CGGHRD, using matrix-matrix",
     "multiplications for parts of the computation to enhance performance."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': do not compute Q;",
       "         = 'I': Q is initialized to the unit matrix, and the",
       "                unitary matrix Q is returned;",
       "         = 'V': Q must contain a unitary matrix Q1 on entry,",
       "                and the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': do not compute Z;",
       "         = 'I': Z is initialized to the unit matrix, and the",
       "                unitary matrix Z is returned;",
       "         = 'V': Z must contain a unitary matrix Z1 on entry,",
       "                and the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of A which are to be",
       "         reduced.  It is assumed that A is already upper triangular",
       "         in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are",
       "         normally set by a previous call to ZGGBAL; otherwise they",
       "         should be set to 1 and N respectively.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         rest is set to zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the N-by-N upper triangular matrix B.",
       "         On exit, the upper triangular matrix T = Q**H B Z.  The",
       "         elements below the diagonal are set to zero."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the unitary matrix Q1, typically",
       "         from the QR factorization of B.",
       "         On exit, if COMPQ='I', the unitary matrix Q, and if",
       "         COMPQ = 'V', the product Q1*Q.",
       "         Not referenced if COMPQ='N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the unitary matrix Z1.",
       "         On exit, if COMPZ='I', the unitary matrix Z, and if",
       "         COMPZ = 'V', the product Z1*Z.",
       "         Not referenced if COMPZ='N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.",
       "         LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= 1.",
       "         For optimum performance LWORK >= 6*N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "chetrs2"=>
  {"summary"=>
    ["CHETRS2 solves a system of linear equations A*X = B with a complex",
     "Hermitian matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by CHETRF and converted by CSYCONV."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CHETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaisnan"=>
  {"summary"=>
    ["This routine is not for general use.  It exists solely to avoid",
     "over-optimization in DISNAN.",
     "DLAISNAN checks for NaNs by comparing its two arguments for",
     "inequality.  NaN is the only floating-point value where NaN != NaN",
     "returns .TRUE.  To check for NaNs, pass the same variable as both",
     "arguments.",
     "A compiler must assume that the two arguments are",
     "not the same variable, and the test will not be optimized away.",
     "Interprocedural or whole-program optimization may delete this",
     "test.  The ISNAN functions will be replaced by the correct",
     "Fortran 03 intrinsic once the intrinsic is widely available."],
   "param"=>
    {"DIN1"=>["[in]", "         DIN1 is DOUBLE PRECISION"],
     "DIN2"=>
      ["[in]",
       "         DIN2 is DOUBLE PRECISION",
       "         Two numbers to compare for inequality."]}},
 "ctpqrt"=>
  {"summary"=>
    ["CTPQRT computes a blocked QR factorization of a complex",
     "\"triangular-pentagonal\" matrix C, which is composed of a",
     "triangular block A and pentagonal block B, using the compact",
     "WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of the",
       "         triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the upper trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.  N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the upper triangular N-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first M-L rows",
       "         are rectangular, and the last L rows are upper trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,N)",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (NB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dbdsdc"=>
  {"summary"=>
    ["DBDSDC computes the singular value decomposition (SVD) of a real",
     "N-by-N (upper or lower) bidiagonal matrix B:  B = U * S * VT,",
     "using a divide and conquer method, where S is a diagonal matrix",
     "with non-negative diagonal elements (the singular values of B), and",
     "U and VT are orthogonal matrices of left and right singular vectors,",
     "respectively. DBDSDC can be used to compute all singular values,",
     "and optionally, singular vectors or singular vectors in compact form.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none.  See DLASD3 for details.",
     "The code currently calls DLASDQ if singular values only are desired.",
     "However, it can be slightly modified to compute singular values",
     "using the divide and conquer method."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  B is upper bidiagonal.",
       "         = 'L':  B is lower bidiagonal."],
     "COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         Specifies whether singular vectors are to be computed",
       "         as follows:",
       "         = 'N':  Compute singular values only;",
       "         = 'P':  Compute singular values and compute singular",
       "                 vectors in compact form;",
       "         = 'I':  Compute singular values and singular vectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix B.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the bidiagonal matrix B.",
       "         On exit, if INFO=0, the singular values of B."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the elements of E contain the offdiagonal",
       "         elements of the bidiagonal matrix whose SVD is desired.",
       "         On exit, E has been destroyed."],
     "U"=>
      ["[out]",
       "         U is DOUBLE PRECISION array, dimension (LDU,N)",
       "         If  COMPQ = 'I', then:",
       "            On exit, if INFO = 0, U contains the left singular vectors",
       "            of the bidiagonal matrix.",
       "         For other values of COMPQ, U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1.",
       "         If singular vectors are desired, then LDU >= max( 1, N )."],
     "VT"=>
      ["[out]",
       "         VT is DOUBLE PRECISION array, dimension (LDVT,N)",
       "         If  COMPQ = 'I', then:",
       "            On exit, if INFO = 0, VT**T contains the right singular",
       "            vectors of the bidiagonal matrix.",
       "         For other values of COMPQ, VT is not referenced."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1.",
       "         If singular vectors are desired, then LDVT >= max( 1, N )."],
     "Q"=>
      ["[out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ)",
       "         If  COMPQ = 'P', then:",
       "            On exit, if INFO = 0, Q and IQ contain the left",
       "            and right singular vectors in a compact form,",
       "            requiring O(N log N) space instead of 2*N**2.",
       "            In particular, Q contains all the DOUBLE PRECISION data in",
       "            LDQ >= N*(11 + 2*SMLSIZ + 8*INT(LOG_2(N/(SMLSIZ+1))))",
       "            words of memory, where SMLSIZ is returned by ILAENV and",
       "            is equal to the maximum size of the subproblems at the",
       "            bottom of the computation tree (usually about 25).",
       "         For other values of COMPQ, Q is not referenced."],
     "IQ"=>
      ["[out]",
       "         IQ is INTEGER array, dimension (LDIQ)",
       "         If  COMPQ = 'P', then:",
       "            On exit, if INFO = 0, Q and IQ contain the left",
       "            and right singular vectors in a compact form,",
       "            requiring O(N log N) space instead of 2*N**2.",
       "            In particular, IQ contains all INTEGER data in",
       "            LDIQ >= N*(3 + 3*INT(LOG_2(N/(SMLSIZ+1))))",
       "            words of memory, where SMLSIZ is returned by ILAENV and",
       "            is equal to the maximum size of the subproblems at the",
       "            bottom of the computation tree (usually about 25).",
       "         For other values of COMPQ, IQ is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         If COMPQ = 'N' then LWORK >= (4 * N).",
       "         If COMPQ = 'P' then LWORK >= (6 * N).",
       "         If COMPQ = 'I' then LWORK >= (3 * N**2 + 4 * N)."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (8*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The algorithm failed to compute a singular value.",
       "               The update process of divide and conquer failed."]}},
 "dlaqgb"=>
  {"summary"=>
    ["DLAQGB equilibrates a general M by N band matrix A with KL",
     "subdiagonals and KU superdiagonals using the row and scaling factors",
     "in the vectors R and C."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, the equilibrated matrix, in the same storage format",
       "         as A.  See EQUED for the form of the equilibrated matrix."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDA >= KL+KU+1."],
     "R"=>
      ["[in]",
       "         R is DOUBLE PRECISION array, dimension (M)",
       "         The row scale factors for A."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "         The column scale factors for A."],
     "ROWCND"=>
      ["[in]",
       "         ROWCND is DOUBLE PRECISION",
       "         Ratio of the smallest R(i) to the largest R(i)."],
     "COLCND"=>
      ["[in]",
       "         COLCND is DOUBLE PRECISION",
       "         Ratio of the smallest C(i) to the largest C(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies the form of equilibration that was done.",
       "         = 'N':  No equilibration",
       "         = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "                 diag(R).",
       "         = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "                 by diag(C).",
       "         = 'B':  Both row and column equilibration, i.e., A has been",
       "                 replaced by diag(R) * A * diag(C)."]}},
 "cptcon"=>
  {"summary"=>
    ["CPTCON computes the reciprocal of the condition number (in the",
     "1-norm) of a complex Hermitian positive definite tridiagonal matrix",
     "using the factorization A = L*D*L**H or A = U**H*D*U computed by",
     "CPTTRF.",
     "Norm(inv(A)) is computed by a direct method, and the reciprocal of",
     "the condition number is computed as",
     "                 RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         factorization of A, as computed by CPTTRF."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the unit bidiagonal factor",
       "         U or L from the factorization of A, as computed by CPTTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is the",
       "         1-norm of inv(A) computed in this routine."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlange"=>
  {"summary"=>
    ["DLANGE  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "real matrix A.",
     "   DLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANGE as described",
       "         above."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0.  When M = 0,",
       "         DLANGE is set to zero."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0.  When N = 0,",
       "         DLANGE is set to zero."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= M when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "dlag2"=>
  {"summary"=>
    ["DLAG2 computes the eigenvalues of a 2 x 2 generalized eigenvalue",
     "problem  A - w B, with scaling as necessary to avoid over-/underflow.",
     "The scaling factor \"s\" results in a modified eigenvalue equation",
     "    s A - w B",
     "where  s  is a non-negative scaling factor chosen so that  w,  w B,",
     "and  s A  do not overflow and, if possible, do not underflow, either."],
   "param"=>
    {"A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA, 2)",
       "         On entry, the 2 x 2 matrix A.  It is assumed that its 1-norm",
       "         is less than 1/SAFMIN.  Entries less than",
       "         sqrt(SAFMIN)*norm(A) are subject to being treated as zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= 2."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB, 2)",
       "         On entry, the 2 x 2 upper triangular matrix B.  It is",
       "         assumed that the one-norm of B is less than 1/SAFMIN.  The",
       "         diagonals should be at least sqrt(SAFMIN) times the largest",
       "         element of B (in absolute value); if a diagonal is smaller",
       "         than that, then  +/- sqrt(SAFMIN) will be used instead of",
       "         that diagonal."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= 2."],
     "SAFMIN"=>
      ["[in]",
       "         SAFMIN is DOUBLE PRECISION",
       "         The smallest positive number s.t. 1/SAFMIN does not",
       "         overflow.  (This should always be DLAMCH('S') -- it is an",
       "         argument in order to avoid having to call DLAMCH frequently.)"],
     "SCALE1"=>
      ["[out]",
       "         SCALE1 is DOUBLE PRECISION",
       "         A scaling factor used to avoid over-/underflow in the",
       "         eigenvalue equation which defines the first eigenvalue.  If",
       "         the eigenvalues are complex, then the eigenvalues are",
       "         ( WR1  +/-  WI i ) / SCALE1  (which may lie outside the",
       "         exponent range of the machine), SCALE1=SCALE2, and SCALE1",
       "         will always be positive.  If the eigenvalues are real, then",
       "         the first (real) eigenvalue is  WR1 / SCALE1 , but this may",
       "         overflow or underflow, and in fact, SCALE1 may be zero or",
       "         less than the underflow threshold if the exact eigenvalue",
       "         is sufficiently large."],
     "SCALE2"=>
      ["[out]",
       "         SCALE2 is DOUBLE PRECISION",
       "         A scaling factor used to avoid over-/underflow in the",
       "         eigenvalue equation which defines the second eigenvalue.  If",
       "         the eigenvalues are complex, then SCALE2=SCALE1.  If the",
       "         eigenvalues are real, then the second (real) eigenvalue is",
       "         WR2 / SCALE2 , but this may overflow or underflow, and in",
       "         fact, SCALE2 may be zero or less than the underflow",
       "         threshold if the exact eigenvalue is sufficiently large."],
     "WR1"=>
      ["[out]",
       "         WR1 is DOUBLE PRECISION",
       "         If the eigenvalue is real, then WR1 is SCALE1 times the",
       "         eigenvalue closest to the (2,2) element of A B**(-1).  If the",
       "         eigenvalue is complex, then WR1=WR2 is SCALE1 times the real",
       "         part of the eigenvalues."],
     "WR2"=>
      ["[out]",
       "         WR2 is DOUBLE PRECISION",
       "         If the eigenvalue is real, then WR2 is SCALE2 times the",
       "         other eigenvalue.  If the eigenvalue is complex, then",
       "         WR1=WR2 is SCALE1 times the real part of the eigenvalues."],
     "WI"=>
      ["[out]",
       "         WI is DOUBLE PRECISION",
       "         If the eigenvalue is real, then WI is zero.  If the",
       "         eigenvalue is complex, then WI is SCALE1 times the imaginary",
       "         part of the eigenvalues.  WI will always be non-negative."]}},
 "cgeequ"=>
  {"summary"=>
    ["CGEEQU computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.",
     "R(i) and C(j) are restricted to be between SMLNUM = smallest safe",
     "number and BIGNUM = largest safe number.  Use of these scaling",
     "factors is not guaranteed to reduce the condition number of A but",
     "works well in practice."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The M-by-N matrix whose equilibration factors are",
       "         to be computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is REAL array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is REAL array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is REAL",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is REAL",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "ctpcon"=>
  {"summary"=>
    ["CTPCON estimates the reciprocal of the condition number of a packed",
     "triangular matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cunbdb"=>
  {"summary"=>
    ["CUNBDB simultaneously bidiagonalizes the blocks of an M-by-M",
     "partitioned unitary matrix X:",
     "                                [ B11 | B12 0  0 ]",
     "    [ X11 | X12 ]   [ P1 |    ] [  0  |  0 -I  0 ] [ Q1 |    ]**H",
     "X = [-----------] = [---------] [----------------] [---------]   .",
     "    [ X21 | X22 ]   [    | P2 ] [ B21 | B22 0  0 ] [    | Q2 ]",
     "                                [  0  |  0  0  I ]",
     "X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is",
     "not the case, then X must be transposed and/or permuted. This can be",
     "done in constant time using the TRANS and SIGNS options. See CUNCSD",
     "for details.)",
     "The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by-",
     "(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are",
     "represented implicitly by Householder vectors.",
     "B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented",
     "implicitly by angles THETA, PHI."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "SIGNS"=>
      ["[in]",
       "         SIGNS is CHARACTER",
       "         = 'O':      The lower-left block is made nonpositive (the",
       "                     \"other\" convention);",
       "         otherwise:  The upper-right block is made nonpositive (the",
       "                     \"default\" convention)."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11 and X12. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <=",
       "         MIN(P,M-P,M-Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX array, dimension (LDX11,Q)",
       "         On entry, the top-left block of the unitary matrix to be",
       "         reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the columns of tril(X11) specify reflectors for P1,",
       "            the rows of triu(X11,1) specify reflectors for Q1;",
       "         else TRANS = 'T', and",
       "            the rows of triu(X11) specify reflectors for P1,",
       "            the columns of tril(X11,-1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. If TRANS = 'N', then LDX11 >=",
       "         P; else LDX11 >= Q."],
     "X12"=>
      ["[in,out]",
       "         X12 is COMPLEX array, dimension (LDX12,M-Q)",
       "         On entry, the top-right block of the unitary matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the rows of triu(X12) specify the first P reflectors for",
       "            Q2;",
       "         else TRANS = 'T', and",
       "            the columns of tril(X12) specify the first P reflectors",
       "            for Q2."],
     "LDX12"=>
      ["[in]",
       "         LDX12 is INTEGER",
       "         The leading dimension of X12. If TRANS = 'N', then LDX12 >=",
       "         P; else LDX11 >= M-Q."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX array, dimension (LDX21,Q)",
       "         On entry, the bottom-left block of the unitary matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the columns of tril(X21) specify reflectors for P2;",
       "         else TRANS = 'T', and",
       "            the rows of triu(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "         The leading dimension of X21. If TRANS = 'N', then LDX21 >=",
       "         M-P; else LDX21 >= Q."],
     "X22"=>
      ["[in,out]",
       "         X22 is COMPLEX array, dimension (LDX22,M-Q)",
       "         On entry, the bottom-right block of the unitary matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the rows of triu(X22(Q+1:M-P,P+1:M-Q)) specify the last",
       "            M-P-Q reflectors for Q2,",
       "         else TRANS = 'T', and",
       "            the columns of tril(X22(P+1:M-Q,Q+1:M-P)) specify the last",
       "            M-P-Q reflectors for P2."],
     "LDX22"=>
      ["[in]",
       "         LDX22 is INTEGER",
       "         The leading dimension of X22. If TRANS = 'N', then LDX22 >=",
       "         M-P; else LDX22 >= M-Q."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (Q)",
       "         The entries of the bidiagonal blocks B11, B12, B21, B22 can",
       "         be computed from the angles THETA and PHI. See Further",
       "         Details."],
     "PHI"=>
      ["[out]",
       "         PHI is REAL array, dimension (Q-1)",
       "         The entries of the bidiagonal blocks B11, B12, B21, B22 can",
       "         be computed from the angles THETA and PHI. See Further",
       "         Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is COMPLEX array, dimension (P)",
       "         The scalar factors of the elementary reflectors that define",
       "         P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is COMPLEX array, dimension (M-P)",
       "         The scalar factors of the elementary reflectors that define",
       "         P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is COMPLEX array, dimension (Q)",
       "         The scalar factors of the elementary reflectors that define",
       "         Q1."],
     "TAUQ2"=>
      ["[out]",
       "         TAUQ2 is COMPLEX array, dimension (M-Q)",
       "         The scalar factors of the elementary reflectors that define",
       "         Q2."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= M-Q.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ssyevd"=>
  {"summary"=>
    ["SSYEVD computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric matrix A. If eigenvectors are desired, it uses a",
     "divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none.",
     "Because of large use of BLAS of level 3, SSYEVD needs N**2 more",
     "workspace than SSYEVX."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array,",
       "                                        dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be at least 2*N+1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least",
       "                                               1 + 6*N + 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i and JOBZ = 'N', then the algorithm failed",
       "               to converge; i off-diagonal elements of an intermediate",
       "               tridiagonal form did not converge to zero;",
       "               if INFO = i and JOBZ = 'V', then the algorithm failed",
       "               to compute an eigenvalue while working on the submatrix",
       "               lying in rows and columns INFO/(N+1) through",
       "               mod(INFO,N+1)."]}},
 "cgetsls"=>
  {"summary"=>
    ["CGETSLS solves overdetermined or underdetermined complex linear systems",
     "involving an M-by-N matrix A, using a tall skinny QR or short wide LQ",
     "factorization of A.  It is assumed that A has full rank.",
     "The following options are provided:",
     "1. If TRANS = 'N' and m >= n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A*X ||.",
     "2. If TRANS = 'N' and m < n:  find the minimum norm solution of",
     "   an underdetermined system A * X = B.",
     "3. If TRANS = 'C' and m >= n:  find the minimum norm solution of",
     "   an undetermined system A**T * X = B.",
     "4. If TRANS = 'C' and m < n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A**T * X ||.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': the linear system involves A;",
       "         = 'C': the linear system involves A**C."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of the matrices B and X. NRHS >=0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         A is overwritten by details of its QR or LQ",
       "         factorization as returned by CGEQR or CGELQ."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the matrix B of right hand side vectors, stored",
       "         columnwise; B is M-by-NRHS if TRANS = 'N', or N-by-NRHS",
       "         if TRANS = 'C'.",
       "         On exit, if INFO = 0, B is overwritten by the solution",
       "         vectors, stored columnwise:",
       "         if TRANS = 'N' and m >= n, rows 1 to n of B contain the least",
       "         squares solution vectors.",
       "         if TRANS = 'N' and m < n, rows 1 to N of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'C' and m >= n, rows 1 to M of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'C' and m < n, rows 1 to M of B contain the",
       "         least squares solution vectors."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= MAX(1,M,N)."],
     "WORK"=>
      ["[out]",
       "         (workspace) COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO =  i, the i-th diagonal element of the",
       "               triangular factor of A is zero, so that A does not have",
       "               full rank; the least squares solution could not be",
       "               computed."]}},
 "dsyrfs"=>
  {"summary"=>
    ["DSYRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric indefinite, and",
     "provides error bounds and backward error estimates for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "         The factored form of the matrix A.  AF contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**T or",
       "         A = L*D*L**T as computed by DSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by DSYTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slaln2"=>
  {"summary"=>
    ["SLALN2 solves a system of the form  (ca A - w D ) X = s B",
     "or (ca A**T - w D) X = s B   with possible scaling (\"s\") and",
     "perturbation of A.  (A**T means A-transpose.)",
     "A is an NA x NA real matrix, ca is a real scalar, D is an NA x NA",
     "real diagonal matrix, w is a real or complex value, and X and B are",
     "NA x 1 matrices -- real if w is real, complex if w is complex.  NA",
     "may be 1 or 2.",
     "If w is complex, X and B are represented as NA x 2 matrices,",
     "the first column of each being the real part and the second",
     "being the imaginary part.",
     "\"s\" is a scaling factor (.LE. 1), computed by SLALN2, which is",
     "so chosen that X can be computed without overflow.  X is further",
     "scaled if necessary to assure that norm(ca A - w D)*norm(X) is less",
     "than overflow.",
     "If both singular values of (ca A - w D) are less than SMIN,",
     "SMIN*identity will be used instead of (ca A - w D).  If only one",
     "singular value is less than SMIN, one element of (ca A - w D) will be",
     "perturbed enough to make the smallest singular value roughly SMIN.",
     "If both singular values are at least SMIN, (ca A - w D) will not be",
     "perturbed.  In any case, the perturbation will be at most some small",
     "multiple of max( SMIN, ulp*norm(ca A - w D) ).  The singular values",
     "are computed by infinity-norm approximations, and thus will only be",
     "correct to a factor of 2 or so.",
     "Note: all input quantities are assumed to be smaller than overflow",
     "by a reasonable factor.  (See BIGNUM.)"],
   "param"=>
    {"LTRANS"=>
      ["[in]",
       "         LTRANS is LOGICAL",
       "         =.TRUE.:  A-transpose will be used.",
       "         =.FALSE.: A will be used (not transposed.)"],
     "NA"=>
      ["[in]",
       "         NA is INTEGER",
       "         The size of the matrix A.  It may (only) be 1 or 2."],
     "NW"=>
      ["[in]",
       "         NW is INTEGER",
       "         1 if \"w\" is real, 2 if \"w\" is complex.  It may only be 1",
       "         or 2."],
     "SMIN"=>
      ["[in]",
       "         SMIN is REAL",
       "         The desired lower bound on the singular values of A.  This",
       "         should be a safe distance away from underflow or overflow,",
       "         say, between (underflow/machine precision) and  (machine",
       "         precision * overflow ).  (See BIGNUM and ULP.)"],
     "CA"=>
      ["[in]",
       "         CA is REAL",
       "         The coefficient c, which A is multiplied by."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,NA)",
       "         The NA x NA matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  It must be at least NA."],
     "D1"=>
      ["[in]",
       "         D1 is REAL",
       "         The 1,1 element in the diagonal matrix D."],
     "D2"=>
      ["[in]",
       "         D2 is REAL",
       "         The 2,2 element in the diagonal matrix D.  Not used if NA=1."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NW)",
       "         The NA x NW matrix B (right-hand side).  If NW=2 (\"w\" is",
       "         complex), column 1 contains the real part of B and column 2",
       "         contains the imaginary part."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  It must be at least NA."],
     "WR"=>
      ["[in]",
       "         WR is REAL",
       "         The real part of the scalar \"w\"."],
     "WI"=>
      ["[in]",
       "         WI is REAL",
       "         The imaginary part of the scalar \"w\".  Not used if NW=1."],
     "X"=>
      ["[out]",
       "         X is REAL array, dimension (LDX,NW)",
       "         The NA x NW matrix X (unknowns), as computed by SLALN2.",
       "         If NW=2 (\"w\" is complex), on exit, column 1 will contain",
       "         the real part of X and column 2 will contain the imaginary",
       "         part."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of X.  It must be at least NA."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         The scale factor that B must be multiplied by to insure",
       "         that overflow does not occur when computing X.  Thus,",
       "         (ca A - w D) X  will be SCALE*B, not B (ignoring",
       "         perturbations of A.)  It will be at most 1."],
     "XNORM"=>
      ["[out]",
       "         XNORM is REAL",
       "         The infinity-norm of X, when X is regarded as an NA x NW",
       "         real matrix."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         An error flag.  It will be set to zero if no error occurs,",
       "         a negative number if an argument is in error, or a positive",
       "         number if  ca A - w D  had to be perturbed.",
       "         The possible values are:",
       "         = 0: No error occurred, and (ca A - w D) did not have to be",
       "                perturbed.",
       "         = 1: (ca A - w D) had to be perturbed to make its smallest",
       "              (or only) singular value greater than SMIN.",
       "         NOTE: In the interests of speed, this routine does not",
       "               check the inputs for errors."]}},
 "dpttrs"=>
  {"summary"=>
    ["DPTTRS solves a tridiagonal system of the form",
     "   A * X = B",
     "using the L*D*L**T factorization of A computed by DPTTRF.  D is a",
     "diagonal matrix specified in the vector D, L is a unit bidiagonal",
     "matrix whose subdiagonal is specified in the vector E, and X and B",
     "are N by NRHS matrices."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         L*D*L**T factorization of A."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the unit bidiagonal factor",
       "         L from the L*D*L**T factorization of A.  E can also be regarded",
       "         as the superdiagonal of the unit bidiagonal factor U from the",
       "         factorization A = U**T*D*U."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side vectors B for the system of",
       "         linear equations.",
       "         On exit, the solution vectors, X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "dzsum1"=>
  {"summary"=>
    ["DZSUM1 takes the sum of the absolute values of a complex",
     "vector and returns a double precision result.",
     "Based on DZASUM from the Level 1 BLAS.",
     "The change is to use the 'genuine' absolute value."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements in the vector CX."],
     "CX"=>
      ["[in]",
       "         CX is COMPLEX*16 array, dimension (N)",
       "         The vector whose elements will be summed."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The spacing between successive values of CX.  INCX > 0."]}},
 "zgges"=>
  {"summary"=>
    ["ZGGES computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, the generalized complex Schur",
     "form (S, T), and optionally left and/or right Schur vectors (VSL",
     "and VSR). This gives the generalized Schur factorization",
     "        (A,B) = ( (VSL)*S*(VSR)**H, (VSL)*T*(VSR)**H )",
     "where (VSR)**H is the conjugate-transpose of VSR.",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "triangular matrix S and the upper triangular matrix T. The leading",
     "columns of VSL and VSR then form an unitary basis for the",
     "corresponding left and right eigenspaces (deflating subspaces).",
     "(If only the generalized eigenvalues are needed, use the driver",
     "ZGGEV instead, which is faster.)",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0, and even for both being zero.",
     "A pair of matrices (S,T) is in generalized complex Schur form if S",
     "and T are upper triangular and, in addition, the diagonal elements",
     "of T are non-negative real numbers."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG)."],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is a LOGICAL FUNCTION of two COMPLEX*16 arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         An eigenvalue ALPHA(j)/BETA(j) is selected if",
       "         SELCTG(ALPHA(j),BETA(j)) is true.",
       "         Note that a selected complex eigenvalue may no longer satisfy",
       "         SELCTG(ALPHA(j),BETA(j)) = .TRUE. after ordering, since",
       "         ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned), in this",
       "         case INFO is set to N+2 (See INFO below)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX*16 array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX*16 array, dimension (N)",
       "         On exit,  ALPHA(j)/BETA(j), j=1,...,N, will be the",
       "         generalized eigenvalues.  ALPHA(j), j=1,...,N  and  BETA(j),",
       "         j=1,...,N  are the diagonals of the complex Schur form (A,B)",
       "         output by ZGGES. The  BETA(j) will be non-negative real.",
       "         Note: the quotients ALPHA(j)/BETA(j) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio alpha/beta.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is COMPLEX*16 array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >= 1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is COMPLEX*16 array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,2*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (8*N)"],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         =1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHA(j) and BETA(j) should be correct for",
       "               j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in ZHGEQZ",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in ZTGSEN."]}},
 "dlartgs"=>
  {"summary"=>
    ["DLARTGS generates a plane rotation designed to introduce a bulge in",
     "Golub-Reinsch-style implicit QR iteration for the bidiagonal SVD",
     "problem. X and Y are the top-row entries, and SIGMA is the shift.",
     "The computed CS and SN define a plane rotation satisfying",
     "   [  CS  SN  ]  .  [ X^2 - SIGMA ]  =  [ R ],",
     "   [ -SN  CS  ]     [    X * Y    ]     [ 0 ]",
     "with R nonnegative.  If X^2 - SIGMA and X * Y are 0, then the",
     "rotation is by PI/2."],
   "param"=>
    {"X"=>
      ["[in]",
       "         X is DOUBLE PRECISION",
       "         The (1,1) entry of an upper bidiagonal matrix."],
     "Y"=>
      ["[in]",
       "         Y is DOUBLE PRECISION",
       "         The (1,2) entry of an upper bidiagonal matrix."],
     "SIGMA"=>
      ["[in]", "         SIGMA is DOUBLE PRECISION", "         The shift."],
     "CS"=>
      ["[out]",
       "         CS is DOUBLE PRECISION",
       "         The cosine of the rotation."],
     "SN"=>
      ["[out]",
       "         SN is DOUBLE PRECISION",
       "         The sine of the rotation."]}},
 "zgetc2"=>
  {"summary"=>
    ["ZGETC2 computes an LU factorization, using complete pivoting, of the",
     "n-by-n matrix A. The factorization has the form A = P * L * U * Q,",
     "where P and Q are permutation matrices, L is lower triangular with",
     "unit diagonal elements and U is upper triangular.",
     "This is a level 1 BLAS version of the algorithm."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the n-by-n matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U*Q; the unit diagonal elements of L are not stored.",
       "         If U(k, k) appears to be less than SMIN, U(k, k) is given the",
       "         value of SMIN, giving a nonsingular perturbed system."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1, N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[out]",
       "         JPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0: successful exit",
       "          > 0: if INFO = k, U(k, k) is likely to produce overflow if",
       "               one tries to solve for x in Ax = b. So U is perturbed",
       "               to avoid the overflow."]}},
 "slahr2"=>
  {"summary"=>
    ["SLAHR2 reduces the first NB columns of A real general n-BY-(n-k+1)",
     "matrix A so that elements below the k-th subdiagonal are zero. The",
     "reduction is performed by an orthogonal similarity transformation",
     "Q**T * A * Q. The routine returns the matrices V and T which determine",
     "Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T.",
     "This is an auxiliary routine called by SGEHRD."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The offset for the reduction. Elements below the k-th",
       "         subdiagonal in the first NB columns are reduced to zero.",
       "         K < N."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of columns to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N-K+1)",
       "         On entry, the n-by-(n-k+1) general matrix A.",
       "         On exit, the elements on and above the k-th subdiagonal in",
       "         the first NB columns are overwritten with the corresponding",
       "         elements of the reduced matrix; the elements below the k-th",
       "         subdiagonal, with the array TAU, represent the matrix Q as a",
       "         product of elementary reflectors. The other columns of A are",
       "         unchanged. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (NB)",
       "         The scalar factors of the elementary reflectors. See Further",
       "         Details."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,NB)",
       "         The upper triangular matrix T."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "Y"=>
      ["[out]",
       "         Y is REAL array, dimension (LDY,NB)",
       "         The n-by-nb matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "         The leading dimension of the array Y. LDY >= N."]}},
 "slaqr0"=>
  {"summary"=>
    ["   SLAQR0 computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**T, where T is an upper quasi-triangular matrix (the",
     "   Schur form), and Z is the orthogonal matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input orthogonal",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the orthogonal matrix Q:  A = Q*H*Q**T = (QZ)*T*(QZ)**T."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N and, if ILO.GT.1,",
       "          H(ILO,ILO-1) is zero. ILO and IHI are normally set by a",
       "          previous call to SGEBAL, and then passed to SGEHRD when the",
       "          matrix output by SGEBAL is reduced to Hessenberg form.",
       "          Otherwise, ILO and IHI should be set to 1 and N,",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is REAL array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and WANTT is .TRUE., then H contains",
       "          the upper quasi-triangular matrix T from the Schur",
       "          decomposition (the Schur form); 2-by-2 diagonal blocks",
       "          (corresponding to complex conjugate pairs of eigenvalues)",
       "          are returned in standard form, with H(i,i) = H(i+1,i+1)",
       "          and H(i+1,i)*H(i,i+1).LT.0. If INFO = 0 and WANTT is",
       "          .FALSE., then the contents of H are unspecified on exit.",
       "          (The output value of H when INFO.GT.0 is given under the",
       "          description of INFO below.)",
       "          This subroutine may explicitly set H(i,j) = 0 for i.GT.j and",
       "          j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "WR"=>["[out]", "         WR is REAL array, dimension (IHI)"],
     "WI"=>
      ["[out]",
       "         WI is REAL array, dimension (IHI)",
       "          The real and imaginary parts, respectively, of the computed",
       "          eigenvalues of H(ILO:IHI,ILO:IHI) are stored in WR(ILO:IHI)",
       "          and WI(ILO:IHI). If two eigenvalues are computed as a",
       "          complex conjugate pair, they are stored in consecutive",
       "          elements of WR and WI, say the i-th and (i+1)th, with",
       "          WI(i) .GT. 0 and WI(i+1) .LT. 0. If WANTT is .TRUE., then",
       "          the eigenvalues are stored in the same order as on the",
       "          diagonal of the Schur form returned in H, with",
       "          WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2 diagonal",
       "          block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and",
       "          WI(i+1) = -WI(i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "          Specify the rows of Z to which transformations must be",
       "          applied if WANTZ is .TRUE..",
       "          1 .LE. ILOZ .LE. ILO; IHI .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ,IHI)",
       "          If WANTZ is .FALSE., then Z is not referenced.",
       "          If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is",
       "          replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the",
       "          orthogonal Schur factor of H(ILO:IHI,ILO:IHI).",
       "          (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if WANTZ is .TRUE.",
       "          then LDZ.GE.MAX(1,IHIZ).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension LWORK",
       "          On exit, if LWORK = -1, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient, but LWORK typically as large as 6*N may",
       "          be required for optimal performance.  A workspace query",
       "          to determine the optimal workspace size is recommended.",
       "          If LWORK = -1, then SLAQR0 does a workspace query.",
       "          In this case, SLAQR0 checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .GT. 0:  if INFO = i, SLAQR0 failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and WANT is .FALSE., then on exit,",
       "               the remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is an orthogonal matrix.  The final",
       "               value of H is upper Hessenberg and quasi-triangular",
       "               in rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                 (final value of Z(ILO:IHI,ILOZ:IHIZ)",
       "                  =  (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U",
       "               where U is the orthogonal matrix in (*) (regard-",
       "               less of the value of WANTT.)",
       "               If INFO .GT. 0 and WANTZ is .FALSE., then Z is not",
       "               accessed."]}},
 "zgsvj0"=>
  {"summary"=>
    ["ZGSVJ0 is called from ZGESVJ as a pre-processor and that is its main",
     "purpose. It applies Jacobi rotations in the same way as ZGESVJ does, but",
     "it does not check convergence (stopping criterion). Few tuning",
     "parameters (marked by [TP]) are available for the implementer."],
   "param"=>
    {"JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether the output from this procedure is used",
       "         to compute the matrix V:",
       "         = 'V': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the N-by-N array V.",
       "               (See the description of V.)",
       "         = 'A': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the MV-by-N array V.",
       "               (See the descriptions of MV and V.)",
       "         = 'N': the Jacobi rotations are not accumulated."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, M-by-N matrix A, such that A*diag(D) represents",
       "         the input matrix.",
       "         On exit,",
       "         A_onexit * diag(D_onexit) represents the input matrix A*diag(D)",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of D, TOL and NSWEEP.)"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX*16 array, dimension (N)",
       "         The array D accumulates the scaling factors from the complex scaled",
       "         Jacobi rotations.",
       "         On entry, A*diag(D) represents the input matrix.",
       "         On exit, A_onexit*diag(D_onexit) represents the input matrix",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of A, TOL and NSWEEP.)"],
     "SVA"=>
      ["[in,out]",
       "         SVA is DOUBLE PRECISION array, dimension (N)",
       "         On entry, SVA contains the Euclidean norms of the columns of",
       "         the matrix A*diag(D).",
       "         On exit, SVA contains the Euclidean norms of the columns of",
       "         the matrix A_onexit*diag(D_onexit)."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then MV is not referenced."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX*16 array, dimension (LDV,N)",
       "         If JOBV .EQ. 'V' then N rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV .EQ. 'A' then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V', LDV .GE. N.",
       "         If JOBV = 'A', LDV .GE. MV."],
     "EPS"=>
      ["[in]",
       "         EPS is DOUBLE PRECISION",
       "         EPS = DLAMCH('Epsilon')"],
     "SFMIN"=>
      ["[in]",
       "         SFMIN is DOUBLE PRECISION",
       "         SFMIN = DLAMCH('Safe Minimum')"],
     "TOL"=>
      ["[in]",
       "         TOL is DOUBLE PRECISION",
       "         TOL is the threshold for Jacobi rotations. For a pair",
       "         A(:,p), A(:,q) of pivot columns, the Jacobi rotation is",
       "         applied only if ABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL."],
     "NSWEEP"=>
      ["[in]",
       "         NSWEEP is INTEGER",
       "         NSWEEP is the number of sweeps of Jacobi rotations to be",
       "         performed."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         LWORK is the dimension of WORK. LWORK .GE. M."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value"]}},
 "clarzb"=>
  {"summary"=>
    ["CLARZB applies a complex block reflector H or its transpose H**H",
     "to a complex distributed M-by-N  C from the left or the right.",
     "Currently, only STOREV = 'R' and DIRECT = 'B' are supported."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H**H from the Left",
       "         = 'R': apply H or H**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'C': apply H**H (Conjugate transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columnwise                        (not supported yet)",
       "         = 'R': Rowwise"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T (= the number of elementary",
       "         reflectors whose product defines the block reflector)."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix V containing the",
       "         meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension (LDV,NV).",
       "         If STOREV = 'C', NV = K; if STOREV = 'R', NV = L."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= L; if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension (LDT,K)",
       "         The triangular K-by-K matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by H*C or H**H*C or C*H or C*H**H."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (LDWORK,K)"],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= max(1,N);",
       "         if SIDE = 'R', LDWORK >= max(1,M)."]}},
 "dsyswapr"=>
  {"summary"=>
    ["DSYSWAPR applies an elementary permutation on the rows and the columns of",
     "a symmetric matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the NB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by DSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "I1"=>
      ["[in]",
       "         I1 is INTEGER",
       "         Index of the first row to swap"],
     "I2"=>
      ["[in]",
       "         I2 is INTEGER",
       "         Index of the second row to swap"]}},
 "csycon"=>
  {"summary"=>
    ["CSYCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex symmetric matrix A using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by CSYTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "claqhb"=>
  {"summary"=>
    ["CLAQHB equilibrates an Hermitian band matrix A using the scaling",
     "factors in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H *U or A = L*L**H of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is REAL",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "zsytrs_3"=>
  {"summary"=>
    ["ZSYTRS_3 solves a system of linear equations A * X = B with a complex",
     "symmetric matrix A using the factorization computed",
     "by ZSYTRF_RK or ZSYTRF_BK:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This algorithm is using Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**T)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**T)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by ZSYTRF_RK and ZSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF_RK or ZSYTRF_BK."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dormhr"=>
  {"summary"=>
    ["DORMHR overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "IHI-ILO elementary reflectors, as returned by DGEHRD:",
     "Q = H(ilo) H(ilo+1) . . . H(ihi-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI must have the same values as in the previous call",
       "         of DGEHRD. Q is equal to the unit matrix except in the",
       "         submatrix Q(ilo+1:ihi,ilo+1:ihi).",
       "         If SIDE = 'L', then 1 <= ILO <= IHI <= M, if M > 0, and",
       "         ILO = 1 and IHI = 0, if M = 0;",
       "         if SIDE = 'R', then 1 <= ILO <= IHI <= N, if N > 0, and",
       "         ILO = 1 and IHI = 0, if N = 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension",
       "                              (LDA,M) if SIDE = 'L'",
       "                              (LDA,N) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by DGEHRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension",
       "                              (M-1) if SIDE = 'L'",
       "                              (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGEHRD."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For optimum performance LWORK >= N*NB if SIDE = 'L', and",
       "         LWORK >= M*NB if SIDE = 'R', where NB is the optimal",
       "         blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgeqr"=>
  {"summary"=>["ZGEQR computes a QR factorization of an M-by-N matrix A."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R",
       "         (R is upper triangular if M >= N);",
       "         the elements below the diagonal are used to store part of the ",
       "         data structure to represent Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (MAX(5,TSIZE))",
       "         On exit, if INFO = 0, T(1) returns optimal (or either minimal ",
       "         or optimal, if query is assumed) TSIZE. See TSIZE for details.",
       "         Remaining T contains part of the data structure used to represent Q.",
       "         If one wants to apply or construct Q, then one needs to keep T ",
       "         (in addition to A) and pass it to further subroutines."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         If TSIZE >= 5, the dimension of the array T.",
       "         If TSIZE = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If TSIZE = -1, the routine calculates optimal size of T for the ",
       "         optimum performance and returns this value in T(1).",
       "         If TSIZE = -2, the routine calculates minimal size of T and ",
       "         returns this value in T(1)."],
     "WORK"=>
      ["[out]",
       "         (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlartg"=>
  {"summary"=>
    ["ZLARTG generates a plane rotation so that",
     "   [  CS  SN  ]     [ F ]     [ R ]",
     "   [  __      ]  .  [   ]  =  [   ]   where CS**2 + |SN|**2 = 1.",
     "   [ -SN  CS  ]     [ G ]     [ 0 ]",
     "This is a faster version of the BLAS1 routine ZROTG, except for",
     "the following differences:",
     "   F and G are unchanged on return.",
     "   If G=0, then CS=1 and SN=0.",
     "   If F=0, then CS=0 and SN is chosen so that R is real."],
   "param"=>
    {"F"=>
      ["[in]",
       "         F is COMPLEX*16",
       "         The first component of vector to be rotated."],
     "G"=>
      ["[in]",
       "         G is COMPLEX*16",
       "         The second component of vector to be rotated."],
     "CS"=>
      ["[out]",
       "         CS is DOUBLE PRECISION",
       "         The cosine of the rotation."],
     "SN"=>
      ["[out]",
       "         SN is COMPLEX*16",
       "         The sine of the rotation."],
     "R"=>
      ["[out]",
       "         R is COMPLEX*16",
       "         The nonzero component of the rotated vector."]}},
 "ctpmlqt"=>
  {"summary"=>
    ["CTPMQRT applies a complex orthogonal matrix Q obtained from a",
     "\"triangular-pentagonal\" real block reflector H to a general",
     "real matrix C, which consists of two blocks A and B."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**C from the Left;",
       "         = 'R': apply Q or Q**C from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**C."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The order of the trapezoidal part of V.",
       "         K >= L >= 0.  See Further Details."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size used for the storage of T.  K >= MB >= 1.",
       "         This must be the same value of MB used to generate T",
       "         in DTPLQT."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension (LDA,K)",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DTPLQT in B.  See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDV >= max(1,M);",
       "         if SIDE = 'R', LDV >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by DTPLQT, stored as a MB-by-K matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension",
       "         (LDA,N) if SIDE = 'L' or",
       "         (LDA,K) if SIDE = 'R'",
       "         On entry, the K-by-N or M-by-K matrix A.",
       "         On exit, A is overwritten by the corresponding block of",
       "         Q*C or Q**C*C or C*Q or C*Q**C.  See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDC >= max(1,K);",
       "         If SIDE = 'R', LDC >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the M-by-N matrix B.",
       "         On exit, B is overwritten by the corresponding block of",
       "         Q*C or Q**C*C or C*Q or C*Q**C.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.",
       "         LDB >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array. The dimension of WORK is",
       "          N*MB if SIDE = 'L', or  M*MB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "stpcon"=>
  {"summary"=>
    ["STPCON estimates the reciprocal of the condition number of a packed",
     "triangular matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgeqrfp"=>
  {"summary"=>
    ["CGEQRFP computes a QR factorization of a complex M-by-N matrix A:",
     "A = Q * R. The diagonal entries of R are real and nonnegative."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n). The diagonal entries of R",
       "         are real and nonnegative; the elements below the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of min(m,n) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slacn2"=>
  {"summary"=>
    ["SLACN2 estimates the 1-norm of a square, real matrix A.",
     "Reverse communication is used for evaluating matrix-vector products."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The order of the matrix.  N >= 1."],
     "V"=>
      ["[out]",
       "         V is REAL array, dimension (N)",
       "        On the final return, V = A*W,  where  EST = norm(V)/norm(W)",
       "        (W is not returned)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (N)",
       "        On an intermediate return, X should be overwritten by",
       "              A * X,   if KASE=1,",
       "              A**T * X,  if KASE=2,",
       "        and SLACN2 must be re-called with all the other parameters",
       "        unchanged."],
     "ISGN"=>["[out]", "         ISGN is INTEGER array, dimension (N)"],
     "EST"=>
      ["[in,out]",
       "         EST is REAL",
       "        On entry with KASE = 1 or 2 and ISAVE(1) = 3, EST should be",
       "        unchanged from the previous call to SLACN2.",
       "        On exit, EST is an estimate (a lower bound) for norm(A)."],
     "KASE"=>
      ["[in,out]",
       "         KASE is INTEGER",
       "        On the initial call to SLACN2, KASE should be 0.",
       "        On an intermediate return, KASE will be 1 or 2, indicating",
       "        whether X should be overwritten by A * X  or A**T * X.",
       "        On the final return from SLACN2, KASE will again be 0."],
     "ISAVE"=>
      ["[in,out]",
       "         ISAVE is INTEGER array, dimension (3)",
       "        ISAVE is used to save variables between calls to SLACN2"]}},
 "spotri"=>
  {"summary"=>
    ["SPOTRI computes the inverse of a real symmetric positive definite",
     "matrix A using the Cholesky factorization A = U**T*U or A = L*L**T",
     "computed by SPOTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T, as computed by",
       "         SPOTRF.",
       "         On exit, the upper or lower triangle of the (symmetric)",
       "         inverse of A, overwriting the input factor U or L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "zlarf"=>
  {"summary"=>
    ["ZLARF applies a complex elementary reflector H to a complex M-by-N",
     "matrix C, from either the left or the right. H is represented in the",
     "form",
     "      H = I - tau * v * v**H",
     "where tau is a complex scalar and v is a complex vector.",
     "If tau = 0, then H is taken to be the unit matrix.",
     "To apply H**H, supply conjg(tau) instead",
     "tau."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension",
       "                    (1 + (M-1)*abs(INCV)) if SIDE = 'L'",
       "                 or (1 + (N-1)*abs(INCV)) if SIDE = 'R'",
       "         The vector v in the representation of H. V is not used if",
       "         TAU = 0."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between elements of v. INCV <> 0."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension",
       "                        (N) if SIDE = 'L'",
       "                     or (M) if SIDE = 'R'"]}},
 "dlals0"=>
  {"summary"=>
    ["DLALS0 applies back the multiplying factors of either the left or the",
     "right singular vector matrix of a diagonal matrix appended by a row",
     "to the right hand side matrix B in solving the least squares problem",
     "using the divide-and-conquer SVD approach.",
     "For the left singular vector matrix, three types of orthogonal",
     "matrices are involved:",
     "(1L) Givens rotations: the number of such rotations is GIVPTR; the",
     "     pairs of columns/rows they were applied to are stored in GIVCOL;",
     "     and the C- and S-values of these rotations are stored in GIVNUM.",
     "(2L) Permutation. The (NL+1)-st row of B is to be moved to the first",
     "     row, and for J=2:N, PERM(J)-th row of B is to be moved to the",
     "     J-th row.",
     "(3L) The left singular vector matrix of the remaining matrix.",
     "For the right singular vector matrix, four types of orthogonal",
     "matrices are involved:",
     "(1R) The right singular vector matrix of the remaining matrix.",
     "(2R) If SQRE = 1, one extra Givens rotation to generate the right",
     "     null space.",
     "(3R) The inverse transformation of (2L).",
     "(4R) The inverse transformation of (1L)."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether singular vectors are to be computed in",
       "        factored form:",
       "        = 0: Left singular vector matrix.",
       "        = 1: Right singular vector matrix."],
     "NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block. NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block. NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has row dimension N = NL + NR + 1,",
       "        and column dimension M = N + SQRE."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B and BX. NRHS must be at least 1."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension ( LDB, NRHS )",
       "        On input, B contains the right hand sides of the least",
       "        squares problem in rows 1 through M. On output, B contains",
       "        the solution X in rows 1 through N."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B. LDB must be at least",
       "        max(1,MAX( M, N ) )."],
     "BX"=>
      ["[out]",
       "         BX is DOUBLE PRECISION array, dimension ( LDBX, NRHS )"],
     "LDBX"=>
      ["[in]",
       "         LDBX is INTEGER",
       "        The leading dimension of BX."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension ( N )",
       "        The permutations (from deflation and sorting) applied",
       "        to the two blocks."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER",
       "        The number of Givens rotations which took place in this",
       "        subproblem."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )",
       "        Each pair of numbers indicates a pair of rows/columns",
       "        involved in a Givens rotation."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER",
       "        The leading dimension of GIVCOL, must be at least N."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is DOUBLE PRECISION array, dimension ( LDGNUM, 2 )",
       "        Each number indicates the C or S value used in the",
       "        corresponding Givens rotation."],
     "LDGNUM"=>
      ["[in]",
       "         LDGNUM is INTEGER",
       "        The leading dimension of arrays DIFR, POLES and",
       "        GIVNUM, must be at least K."],
     "POLES"=>
      ["[in]",
       "         POLES is DOUBLE PRECISION array, dimension ( LDGNUM, 2 )",
       "        On entry, POLES(1:K, 1) contains the new singular",
       "        values obtained from solving the secular equation, and",
       "        POLES(1:K, 2) is an array containing the poles in the secular",
       "        equation."],
     "DIFL"=>
      ["[in]",
       "         DIFL is DOUBLE PRECISION array, dimension ( K ).",
       "        On entry, DIFL(I) is the distance between I-th updated",
       "        (undeflated) singular value and the I-th (undeflated) old",
       "        singular value."],
     "DIFR"=>
      ["[in]",
       "         DIFR is DOUBLE PRECISION array, dimension ( LDGNUM, 2 ).",
       "        On entry, DIFR(I, 1) contains the distances between I-th",
       "        updated (undeflated) singular value and the I+1-th",
       "        (undeflated) old singular value. And DIFR(I, 2) is the",
       "        normalizing factor for the I-th right singular vector."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension ( K )",
       "        Contain the components of the deflation-adjusted updating row",
       "        vector."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "        Contains the dimension of the non-deflated matrix,",
       "        This is the order of the related secular equation. 1 <= K <=N."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION",
       "        C contains garbage if SQRE =0 and the C-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION",
       "        S contains garbage if SQRE =0 and the S-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension ( K )"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slaed0"=>
  {"summary"=>
    ["SLAED0 computes all eigenvalues and corresponding eigenvectors of a",
     "symmetric tridiagonal matrix using the divide and conquer method."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "         = 0:  Compute eigenvalues only.",
       "         = 1:  Compute eigenvectors of original dense symmetric matrix",
       "               also.  On entry, Q contains the orthogonal matrix used",
       "               to reduce the original matrix to tridiagonal form.",
       "         = 2:  Compute eigenvalues and eigenvectors of tridiagonal",
       "               matrix."],
     "QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the orthogonal matrix used to reduce",
       "        the full matrix to tridiagonal form.  QSIZ >= N if ICOMPQ = 1."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry, the main diagonal of the tridiagonal matrix.",
       "        On exit, its eigenvalues."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N-1)",
       "        The off-diagonal elements of the tridiagonal matrix.",
       "        On exit, E has been destroyed."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ, N)",
       "        On entry, Q must contain an N-by-N orthogonal matrix.",
       "        If ICOMPQ = 0    Q is not referenced.",
       "        If ICOMPQ = 1    On entry, Q is a subset of the columns of the",
       "                         orthogonal matrix used to reduce the full",
       "                         matrix to tridiagonal form corresponding to",
       "                         the subset of the full matrix which is being",
       "                         decomposed at this time.",
       "        If ICOMPQ = 2    On entry, Q will be the identity matrix.",
       "                         On exit, Q contains the eigenvectors of the",
       "                         tridiagonal matrix."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  If eigenvectors are",
       "        desired, then  LDQ >= max(1,N).  In any case,  LDQ >= 1."],
     "QSTORE"=>
      ["[out]",
       "         QSTORE is REAL array, dimension (LDQS, N)",
       "        Referenced only when ICOMPQ = 1.  Used to store parts of",
       "        the eigenvector matrix when the updating matrix multiplies",
       "        take place."],
     "LDQS"=>
      ["[in]",
       "         LDQS is INTEGER",
       "        The leading dimension of the array QSTORE.  If ICOMPQ = 1,",
       "        then  LDQS >= max(1,N).  In any case,  LDQS >= 1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array,",
       "        If ICOMPQ = 0 or 1, the dimension of WORK must be at least",
       "                    1 + 3*N + 2*N*lg N + 3*N**2",
       "                    ( lg( N ) = smallest integer k",
       "                                such that 2^k >= N )",
       "        If ICOMPQ = 2, the dimension of WORK must be at least",
       "                    4*N + N**2."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array,",
       "        If ICOMPQ = 0 or 1, the dimension of IWORK must be at least",
       "                       6 + 6*N + 5*N*lg N.",
       "                       ( lg( N ) = smallest integer k",
       "                                   such that 2^k >= N )",
       "        If ICOMPQ = 2, the dimension of IWORK must be at least",
       "                       3 + 5*N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The algorithm failed to compute an eigenvalue while",
       "               working on the submatrix lying in rows and columns",
       "               INFO/(N+1) through mod(INFO,N+1)."]}},
 "dlaebz"=>
  {"summary"=>
    ["DLAEBZ contains the iteration loops which compute and use the",
     "function N(w), which is the count of eigenvalues of a symmetric",
     "tridiagonal matrix T less than or equal to its argument  w.  It",
     "performs a choice of two types of loops:",
     "IJOB=1, followed by",
     "IJOB=2: It takes as input a list of intervals and returns a list of",
     "        sufficiently small intervals whose union contains the same",
     "        eigenvalues as the union of the original intervals.",
     "        The input intervals are (AB(j,1),AB(j,2)], j=1,...,MINP.",
     "        The output interval (AB(j,1),AB(j,2)] will contain",
     "        eigenvalues NAB(j,1)+1,...,NAB(j,2), where 1 <= j <= MOUT.",
     "IJOB=3: It performs a binary search in each input interval",
     "        (AB(j,1),AB(j,2)] for a point  w(j)  such that",
     "        N(w(j))=NVAL(j), and uses  C(j)  as the starting point of",
     "        the search.  If such a w(j) is found, then on output",
     "        AB(j,1)=AB(j,2)=w.  If no such w(j) is found, then on output",
     "        (AB(j,1),AB(j,2)] will be a small interval containing the",
     "        point where N(w) jumps through NVAL(j), unless that point",
     "        lies outside the initial interval.",
     "Note that the intervals are in all cases half-open intervals,",
     "i.e., of the form  (a,b] , which includes  b  but not  a .",
     "To avoid underflow, the matrix should be scaled so that its largest",
     "element is no greater than  overflow**(1/2) * underflow**(1/4)",
     "in absolute value.  To assure the most accurate computation",
     "of small eigenvalues, the matrix should be scaled to be",
     "not much smaller than that, either.",
     "See W. Kahan \"Accurate Eigenvalues of a Symmetric Tridiagonal",
     "Matrix\", Report CS41, Computer Science Dept., Stanford",
     "University, July 21, 1966",
     "Note: the arguments are, in general, *not* checked for unreasonable",
     "values."],
   "param"=>
    {"IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies what is to be done:",
       "         = 1:  Compute NAB for the initial intervals.",
       "         = 2:  Perform bisection iteration to find eigenvalues of T.",
       "         = 3:  Perform bisection iteration to invert N(w), i.e.,",
       "               to find a point which has a specified number of",
       "               eigenvalues of T to its left.",
       "         Other values will cause DLAEBZ to return with INFO=-1."],
     "NITMAX"=>
      ["[in]",
       "         NITMAX is INTEGER",
       "         The maximum number of \"levels\" of bisection to be",
       "         performed, i.e., an interval of width W will not be made",
       "         smaller than 2^(-NITMAX) * W.  If not all intervals",
       "         have converged after NITMAX iterations, then INFO is set",
       "         to the number of non-converged intervals."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The dimension n of the tridiagonal matrix T.  It must be at",
       "         least 1."],
     "MMAX"=>
      ["[in]",
       "         MMAX is INTEGER",
       "         The maximum number of intervals.  If more than MMAX intervals",
       "         are generated, then DLAEBZ will quit with INFO=MMAX+1."],
     "MINP"=>
      ["[in]",
       "         MINP is INTEGER",
       "         The initial number of intervals.  It may not be greater than",
       "         MMAX."],
     "NBMIN"=>
      ["[in]",
       "         NBMIN is INTEGER",
       "         The smallest number of intervals that should be processed",
       "         using a vector loop.  If zero, then only the scalar loop",
       "         will be used."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The minimum (absolute) width of an interval.  When an",
       "         interval is narrower than ABSTOL, or than RELTOL times the",
       "         larger (in magnitude) endpoint, then it is considered to be",
       "         sufficiently small, i.e., converged.  This must be at least",
       "         zero."],
     "RELTOL"=>
      ["[in]",
       "         RELTOL is DOUBLE PRECISION",
       "         The minimum relative width of an interval.  When an interval",
       "         is narrower than ABSTOL, or than RELTOL times the larger (in",
       "         magnitude) endpoint, then it is considered to be",
       "         sufficiently small, i.e., converged.  Note: this should",
       "         always be at least radix*machine epsilon."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "         The minimum absolute value of a \"pivot\" in the Sturm",
       "         sequence loop.",
       "         This must be at least  max |e(j)**2|*safe_min  and at",
       "         least safe_min, where safe_min is at least",
       "         the smallest number that can divide one without overflow."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         The offdiagonal elements of the tridiagonal matrix T in",
       "         positions 1 through N-1.  E(N) is arbitrary."],
     "E2"=>
      ["[in]",
       "         E2 is DOUBLE PRECISION array, dimension (N)",
       "         The squares of the offdiagonal elements of the tridiagonal",
       "         matrix T.  E2(N) is ignored."],
     "NVAL"=>
      ["[in,out]",
       "         NVAL is INTEGER array, dimension (MINP)",
       "         If IJOB=1 or 2, not referenced.",
       "         If IJOB=3, the desired values of N(w).  The elements of NVAL",
       "         will be reordered to correspond with the intervals in AB.",
       "         Thus, NVAL(j) on output will not, in general be the same as",
       "         NVAL(j) on input, but it will correspond with the interval",
       "         (AB(j,1),AB(j,2)] on output."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (MMAX,2)",
       "         The endpoints of the intervals.  AB(j,1) is  a(j), the left",
       "         endpoint of the j-th interval, and AB(j,2) is b(j), the",
       "         right endpoint of the j-th interval.  The input intervals",
       "         will, in general, be modified, split, and reordered by the",
       "         calculation."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (MMAX)",
       "         If IJOB=1, ignored.",
       "         If IJOB=2, workspace.",
       "         If IJOB=3, then on input C(j) should be initialized to the",
       "         first search point in the binary search."],
     "MOUT"=>
      ["[out]",
       "         MOUT is INTEGER",
       "         If IJOB=1, the number of eigenvalues in the intervals.",
       "         If IJOB=2 or 3, the number of intervals output.",
       "         If IJOB=3, MOUT will equal MINP."],
     "NAB"=>
      ["[in,out]",
       "         NAB is INTEGER array, dimension (MMAX,2)",
       "         If IJOB=1, then on output NAB(i,j) will be set to N(AB(i,j)).",
       "         If IJOB=2, then on input, NAB(i,j) should be set.  It must",
       "            satisfy the condition:",
       "            N(AB(i,1)) <= NAB(i,1) <= NAB(i,2) <= N(AB(i,2)),",
       "            which means that in interval i only eigenvalues",
       "            NAB(i,1)+1,...,NAB(i,2) will be considered.  Usually,",
       "            NAB(i,j)=N(AB(i,j)), from a previous call to DLAEBZ with",
       "            IJOB=1.",
       "            On output, NAB(i,j) will contain",
       "            max(na(k),min(nb(k),N(AB(i,j)))), where k is the index of",
       "            the input interval that the output interval",
       "            (AB(j,1),AB(j,2)] came from, and na(k) and nb(k) are the",
       "            the input values of NAB(k,1) and NAB(k,2).",
       "         If IJOB=3, then on output, NAB(i,j) contains N(AB(i,j)),",
       "            unless N(w) > NVAL(i) for all search points  w , in which",
       "            case NAB(i,1) will not be modified, i.e., the output",
       "            value will be the same as the input value (modulo",
       "            reorderings -- see NVAL and AB), or unless N(w) < NVAL(i)",
       "            for all search points  w , in which case NAB(i,2) will",
       "            not be modified.  Normally, NAB should be set to some",
       "            distinctive value(s) before DLAEBZ is called."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MMAX)",
       "         Workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MMAX)",
       "         Workspace."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:       All intervals converged.",
       "         = 1--MMAX: The last INFO intervals did not converge.",
       "         = MMAX+1:  More than MMAX intervals were generated."]}},
 "sgeequb"=>
  {"summary"=>
    ["SGEEQUB computes row and column scalings intended to equilibrate an",
     "M-by-N matrix A and reduce its condition number.  R returns the row",
     "scale factors and C the column scale factors, chosen to try to make",
     "the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have an absolute value of at most",
     "the radix.",
     "R(i) and C(j) are restricted to be a power of the radix between",
     "SMLNUM = smallest safe number and BIGNUM = largest safe number.  Use",
     "of these scaling factors is not guaranteed to reduce the condition",
     "number of A but works well in practice.",
     "This routine differs from SGEEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled entries' magnitudes are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The M-by-N matrix whose equilibration factors are",
       "         to be computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "R"=>
      ["[out]",
       "         R is REAL array, dimension (M)",
       "         If INFO = 0 or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is REAL array, dimension (N)",
       "         If INFO = 0,  C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is REAL",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is REAL",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i,  and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "slasdt"=>
  {"summary"=>
    ["SLASDT creates a tree of subproblems for bidiagonal divide and",
     "conquer."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         On entry, the number of diagonal elements of the",
       "         bidiagonal matrix."],
     "LVL"=>
      ["[out]",
       "         LVL is INTEGER",
       "         On exit, the number of levels on the computation tree."],
     "ND"=>
      ["[out]",
       "         ND is INTEGER",
       "         On exit, the number of nodes on the tree."],
     "INODE"=>
      ["[out]",
       "         INODE is INTEGER array, dimension ( N )",
       "         On exit, centers of subproblems."],
     "NDIML"=>
      ["[out]",
       "         NDIML is INTEGER array, dimension ( N )",
       "         On exit, row dimensions of left children."],
     "NDIMR"=>
      ["[out]",
       "         NDIMR is INTEGER array, dimension ( N )",
       "         On exit, row dimensions of right children."],
     "MSUB"=>
      ["[in]",
       "         MSUB is INTEGER",
       "         On entry, the maximum row dimension each subproblem at the",
       "         bottom of the tree can be of."]}},
 "zlarfb"=>
  {"summary"=>
    ["ZLARFB applies a complex block reflector H or its transpose H**H to a",
     "complex M-by-N matrix C, from either the left or the right."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H**H from the Left",
       "         = 'R': apply H or H**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'C': apply H**H (Conjugate transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columnwise",
       "         = 'R': Rowwise"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T (= the number of elementary",
       "         reflectors whose product defines the block reflector)."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension",
       "                               (LDV,K) if STOREV = 'C'",
       "                               (LDV,M) if STOREV = 'R' and SIDE = 'L'",
       "                               (LDV,N) if STOREV = 'R' and SIDE = 'R'",
       "         See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);",
       "         if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);",
       "         if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension (LDT,K)",
       "         The triangular K-by-K matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by H*C or H**H*C or C*H or C*H**H."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX*16 array, dimension (LDWORK,K)"],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= max(1,N);",
       "         if SIDE = 'R', LDWORK >= max(1,M)."]}},
 "dorgql"=>
  {"summary"=>
    ["DORGQL generates an M-by-N real matrix Q with orthonormal columns,",
     "which is defined as the last N columns of a product of K elementary",
     "reflectors of order M",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by DGEQLF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the (n-k+i)-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by DGEQLF in the last k columns of its array",
       "         argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGEQLF."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "zggglm"=>
  {"summary"=>
    ["ZGGGLM solves a general Gauss-Markov linear model (GLM) problem:",
     "        minimize || y ||_2   subject to   d = A*x + B*y",
     "            x",
     "where A is an N-by-M matrix, B is an N-by-P matrix, and d is a",
     "given N-vector. It is assumed that M <= N <= M+P, and",
     "           rank(A) = M    and    rank( A B ) = N.",
     "Under these assumptions, the constrained equation is always",
     "consistent, and there is a unique solution x and a minimal 2-norm",
     "solution y, which is obtained using a generalized QR factorization",
     "of the matrices (A, B) given by",
     "   A = Q*(R),   B = Q*T*Z.",
     "         (0)",
     "In particular, if matrix B is square nonsingular, then the problem",
     "GLM is equivalent to the following weighted linear least squares",
     "problem",
     "             minimize || inv(B)*(d-A*x) ||_2",
     "                 x",
     "where inv(B) denotes the inverse of B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrices A and B.  N >= 0."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix A.  0 <= M <= N."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of columns of the matrix B.  P >= N-M."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,M)",
       "         On entry, the N-by-M matrix A.",
       "         On exit, the upper triangular part of the array A contains",
       "         the M-by-M upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,P)",
       "         On entry, the N-by-P matrix B.",
       "         On exit, if N <= P, the upper triangle of the subarray",
       "         B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T;",
       "         if N > P, the elements on and above the (N-P)th subdiagonal",
       "         contain the N-by-P upper trapezoidal matrix T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX*16 array, dimension (N)",
       "         On entry, D is the left hand side of the GLM equation.",
       "         On exit, D is destroyed."],
     "X"=>["[out]", "         X is COMPLEX*16 array, dimension (M)"],
     "Y"=>
      ["[out]",
       "         Y is COMPLEX*16 array, dimension (P)",
       "         On exit, X and Y are the solutions of the GLM problem."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N+M+P).",
       "         For optimum performance, LWORK >= M+min(N,P)+max(N,P)*NB,",
       "         where NB is an upper bound for the optimal blocksizes for",
       "         ZGEQRF, ZGERQF, ZUNMQR and ZUNMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the upper triangular factor R associated with A in the",
       "               generalized QR factorization of the pair (A, B) is",
       "               singular, so that rank(A) < M; the least squares",
       "               solution could not be computed.",
       "         = 2:  the bottom (N-M) by (N-M) part of the upper trapezoidal",
       "               factor T associated with B in the generalized QR",
       "               factorization of the pair (A, B) is singular, so that",
       "               rank( A B ) < N; the least squares solution could not",
       "               be computed."]}},
 "cpttrf"=>
  {"summary"=>
    ["CPTTRF computes the L*D*L**H factorization of a complex Hermitian",
     "positive definite tridiagonal matrix A.  The factorization may also",
     "be regarded as having the form A = U**H *D*U."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.  On exit, the n diagonal elements of the diagonal matrix",
       "         D from the L*D*L**H factorization of A."],
     "E"=>
      ["[in,out]",
       "         E is COMPLEX array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A.  On exit, the (n-1) subdiagonal elements of the",
       "         unit bidiagonal factor L from the L*D*L**H factorization of A.",
       "         E can also be regarded as the superdiagonal of the unit",
       "         bidiagonal factor U from the U**H *D*U factorization of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite; if k < N, the factorization could not",
       "              be completed, while if k = N, the factorization was",
       "              completed, but D(N) <= 0."]}},
 "chpgvd"=>
  {"summary"=>
    ["CHPGVD computes all the eigenvalues and, optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and",
     "B are assumed to be Hermitian, stored in packed format, and B is also",
     "positive definite.",
     "If eigenvectors are desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H, in the same storage",
       "         format as B."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors.  The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the required LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of array WORK.",
       "         If N <= 1,               LWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LWORK >= N.",
       "         If JOBZ = 'V' and N > 1, LWORK >= 2*N.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the required sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the required LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK.",
       "         If N <= 1,               LRWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LRWORK >= N.",
       "         If JOBZ = 'V' and N > 1, LRWORK >= 1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the required LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK >= 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  CPPTRF or CHPEVD returned an error code:",
       "            <= N:  if INFO = i, CHPEVD failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not convergeto zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= n, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "claev2"=>
  {"summary"=>
    ["CLAEV2 computes the eigendecomposition of a 2-by-2 Hermitian matrix",
     "   [  A         B  ]",
     "   [  CONJG(B)  C  ].",
     "On return, RT1 is the eigenvalue of larger absolute value, RT2 is the",
     "eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right",
     "eigenvector for RT1, giving the decomposition",
     "[ CS1  CONJG(SN1) ] [    A     B ] [ CS1 -CONJG(SN1) ] = [ RT1  0  ]",
     "[-SN1     CS1     ] [ CONJG(B) C ] [ SN1     CS1     ]   [  0  RT2 ]."],
   "param"=>
    {"A"=>
      ["[in]",
       "         A is COMPLEX",
       "        The (1,1) element of the 2-by-2 matrix."],
     "B"=>
      ["[in]",
       "         B is COMPLEX",
       "        The (1,2) element and the conjugate of the (2,1) element of",
       "        the 2-by-2 matrix."],
     "C"=>
      ["[in]",
       "         C is COMPLEX",
       "        The (2,2) element of the 2-by-2 matrix."],
     "RT1"=>
      ["[out]",
       "         RT1 is REAL",
       "        The eigenvalue of larger absolute value."],
     "RT2"=>
      ["[out]",
       "         RT2 is REAL",
       "        The eigenvalue of smaller absolute value."],
     "CS1"=>["[out]", "         CS1 is REAL"],
     "SN1"=>
      ["[out]",
       "         SN1 is COMPLEX",
       "        The vector (CS1, SN1) is a unit right eigenvector for RT1."]}},
 "dlapy2"=>
  {"summary"=>
    ["DLAPY2 returns sqrt(x**2+y**2), taking care not to cause unnecessary",
     "overflow."],
   "param"=>
    {"X"=>["[in]", "         X is DOUBLE PRECISION"],
     "Y"=>
      ["[in]",
       "         Y is DOUBLE PRECISION",
       "         X and Y specify the values x and y."]}},
 "dpbtf2"=>
  {"summary"=>
    ["DPBTF2 computes the Cholesky factorization of a real symmetric",
     "positive definite band matrix A.",
     "The factorization has the form",
     "   A = U**T * U ,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix, U**T is the transpose of U, and",
     "L is lower triangular.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**T*U or A = L*L**T of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite, and the factorization could not be",
       "              completed."]}},
 "cheev"=>
  {"summary"=>
    ["CHEEV computes all eigenvalues and, optionally, eigenvectors of a",
     "complex Hermitian matrix A."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,2*N-1).",
       "         For optimal efficiency, LWORK >= (NB+1)*N,",
       "         where NB is the blocksize for CHETRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is REAL array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dgbtf2"=>
  {"summary"=>
    ["DGBTF2 computes an LU factorization of a real m-by-n band matrix A",
     "using partial pivoting with row interchanges.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(kl+ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = +i, U(i,i) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "chetrf"=>
  {"summary"=>
    ["CHETRF computes the factorization of a complex Hermitian matrix A",
     "using the Bunch-Kaufman diagonal pivoting method.  The form of the",
     "factorization is",
     "   A = U*D*U**H  or  A = L*D*L**H",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is Hermitian and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "dgesvx"=>
  {"summary"=>
    ["DGESVX uses the LU factorization to compute the solution to a real",
     "system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N matrix and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "clamtsqr"=>
  {"summary"=>
    ["     CLAMTSQR overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**C * C       C * Q**C",
     "     where Q is a real orthogonal matrix defined as the product",
     "     of blocked elementary reflectors computed by tall skinny",
     "     QR factorization (CLATSQR)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate Transpose, apply Q**C."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         N >= K >= 0;"],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.",
       "         MB > N. (must be the same as DLATSQR)"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         blockedelementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by DLATSQR in the first k columns of",
       "         its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension",
       "         ( N * Number of blocks(CEIL(M-K/MB-K)),",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]", "        (workspace) COMPLEX array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N)*NB;",
       "         if SIDE = 'R', LWORK >= max(1,MB)*NB.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlauu2"=>
  {"summary"=>
    ["ZLAUU2 computes the product U * U**H or L**H * L, where the triangular",
     "factor U or L is stored in the upper or lower triangular part of",
     "the array A.",
     "If UPLO = 'U' or 'u' then the upper triangle of the result is stored,",
     "overwriting the factor U in A.",
     "If UPLO = 'L' or 'l' then the lower triangle of the result is stored,",
     "overwriting the factor L in A.",
     "This is the unblocked form of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the triangular factor stored in the array A",
       "         is upper or lower triangular:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the triangular factor U or L.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L.",
       "         On exit, if UPLO = 'U', the upper triangle of A is",
       "         overwritten with the upper triangle of the product U * U**H;",
       "         if UPLO = 'L', the lower triangle of A is overwritten with",
       "         the lower triangle of the product L**H * L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "ssysv_rook"=>
  {"summary"=>
    ["SSYSV_ROOK computes the solution to a real system of linear",
     "equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "SSYTRF_ROOK is called to compute the factorization of a real",
     "symmetric matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal",
     "pivoting method.",
     "The factored form of A is then used to solve the system",
     "of equations A * X = B by calling SSYTRS_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**T or A = L*D*L**T as computed by",
       "         SSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D,",
       "         as determined by SSYTRF_ROOK.",
       "         If UPLO = 'U':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k-1 and -IPIV(k-1) were inerchaged,",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "              If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "              were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "              columns k and -IPIV(k) were interchanged and rows and",
       "              columns k+1 and -IPIV(k+1) were inerchaged,",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         SSYTRF_ROOK.",
       "         TRS will be done with Level 2 BLAS",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "zspcon"=>
  {"summary"=>
    ["ZSPCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex symmetric packed matrix A using the",
     "factorization A = U*D*U**T or A = L*D*L**T computed by ZSPTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZSPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSPTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlarrr"=>
  {"summary"=>
    ["Perform tests to decide whether the symmetric tridiagonal matrix T",
     "warrants expensive computations which guarantee high relative accuracy",
     "in the eigenvalues."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix. N > 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The N diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the first (N-1) entries contain the subdiagonal",
       "         elements of the tridiagonal matrix T; E(N) is set to ZERO."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         INFO = 0(default) : the matrix warrants computations preserving",
       "                             relative accuracy.",
       "         INFO = 1          : the matrix warrants computations guaranteeing",
       "                             only absolute accuracy."]}},
 "zlaswp"=>
  {"summary"=>
    ["ZLASWP performs a series of row interchanges on the matrix A.",
     "One row interchange is initiated for each of rows K1 through K2 of A."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the matrix of column dimension N to which the row",
       "         interchanges will be applied.",
       "         On exit, the permuted matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A."],
     "K1"=>
      ["[in]",
       "         K1 is INTEGER",
       "         The first element of IPIV for which a row interchange will",
       "         be done."],
     "K2"=>
      ["[in]",
       "         K2 is INTEGER",
       "         (K2-K1+1) is the number of elements of IPIV for which a row",
       "         interchange will be done."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (K1+(K2-K1)*abs(INCX))",
       "         The vector of pivot indices. Only the elements in positions",
       "         K1 through K1+(K2-K1)*INCX of IPIV are accessed.",
       "         IPIV(K) = L implies rows K and L are to be interchanged."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of IPIV.  If IPIV",
       "         is negative, the pivots are applied in reverse order."]}},
 "zggqrf"=>
  {"summary"=>
    ["ZGGQRF computes a generalized QR factorization of an N-by-M matrix A",
     "and an N-by-P matrix B:",
     "            A = Q*R,        B = Q*T*Z,",
     "where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix,",
     "and R and T assume one of the forms:",
     "if N >= M,  R = ( R11 ) M  ,   or if N < M,  R = ( R11  R12 ) N,",
     "                (  0  ) N-M                         N   M-N",
     "                   M",
     "where R11 is upper triangular, and",
     "if N <= P,  T = ( 0  T12 ) N,   or if N > P,  T = ( T11 ) N-P,",
     "                 P-N  N                           ( T21 ) P",
     "                                                     P",
     "where T12 or T21 is upper triangular.",
     "In particular, if B is square and nonsingular, the GQR factorization",
     "of A and B implicitly gives the QR factorization of inv(B)*A:",
     "             inv(B)*A = Z**H * (inv(T)*R)",
     "where inv(B) denotes the inverse of the matrix B, and Z**H denotes the",
     "conjugate transpose of matrix Z."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrices A and B. N >= 0."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of columns of the matrix B.  P >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,M)",
       "         On entry, the N-by-M matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(N,M)-by-M upper trapezoidal matrix R (R is",
       "         upper triangular if N >= M); the elements below the diagonal,",
       "         with the array TAUA, represent the unitary matrix Q as a",
       "         product of min(N,M) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "TAUA"=>
      ["[out]",
       "         TAUA is COMPLEX*16 array, dimension (min(N,M))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Q (see Further Details)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,P)",
       "         On entry, the N-by-P matrix B.",
       "         On exit, if N <= P, the upper triangle of the subarray",
       "         B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T;",
       "         if N > P, the elements on and above the (N-P)-th subdiagonal",
       "         contain the N-by-P upper trapezoidal matrix T; the remaining",
       "         elements, with the array TAUB, represent the unitary",
       "         matrix Z as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "TAUB"=>
      ["[out]",
       "         TAUB is COMPLEX*16 array, dimension (min(N,P))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Z (see Further Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N,M,P).",
       "         For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),",
       "         where NB1 is the optimal blocksize for the QR factorization",
       "         of an N-by-M matrix, NB2 is the optimal blocksize for the",
       "         RQ factorization of an N-by-P matrix, and NB3 is the optimal",
       "         blocksize for a call of ZUNMQR.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slarrf"=>
  {"summary"=>
    ["Given the initial representation L D L^T and its cluster of close",
     "eigenvalues (in a relative measure), W( CLSTRT ), W( CLSTRT+1 ), ...",
     "W( CLEND ), SLARRF finds a new relatively robust representation",
     "L D L^T - SIGMA I = L(+) D(+) L(+)^T such that at least one of the",
     "eigenvalues of L(+) D(+) L(+)^T is relatively isolated."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix (subblock, if the matrix split)."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The N diagonal elements of the diagonal matrix D."],
     "L"=>
      ["[in]",
       "         L is REAL array, dimension (N-1)",
       "         The (N-1) subdiagonal elements of the unit bidiagonal",
       "         matrix L."],
     "LD"=>
      ["[in]",
       "         LD is REAL array, dimension (N-1)",
       "         The (N-1) elements L(i)*D(i)."],
     "CLSTRT"=>
      ["[in]",
       "         CLSTRT is INTEGER",
       "         The index of the first eigenvalue in the cluster."],
     "CLEND"=>
      ["[in]",
       "         CLEND is INTEGER",
       "         The index of the last eigenvalue in the cluster."],
     "W"=>
      ["[in]",
       "         W is REAL array, dimension",
       "         dimension is >=  (CLEND-CLSTRT+1)",
       "         The eigenvalue APPROXIMATIONS of L D L^T in ascending order.",
       "         W( CLSTRT ) through W( CLEND ) form the cluster of relatively",
       "         close eigenalues."],
     "WGAP"=>
      ["[in,out]",
       "         WGAP is REAL array, dimension",
       "         dimension is >=  (CLEND-CLSTRT+1)",
       "         The separation from the right neighbor eigenvalue in W."],
     "WERR"=>
      ["[in]",
       "         WERR is REAL array, dimension",
       "         dimension is >=  (CLEND-CLSTRT+1)",
       "         WERR contain the semiwidth of the uncertainty",
       "         interval of the corresponding eigenvalue APPROXIMATION in W"],
     "SPDIAM"=>
      ["[in]",
       "         SPDIAM is REAL",
       "         estimate of the spectral diameter obtained from the",
       "         Gerschgorin intervals"],
     "CLGAPL"=>["[in]", "         CLGAPL is REAL"],
     "CLGAPR"=>
      ["[in]",
       "         CLGAPR is REAL",
       "         absolute gap on each end of the cluster.",
       "         Set by the calling routine to protect against shifts too close",
       "         to eigenvalues outside the cluster."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "         The minimum pivot allowed in the Sturm sequence."],
     "SIGMA"=>
      ["[out]",
       "         SIGMA is REAL",
       "         The shift used to form L(+) D(+) L(+)^T."],
     "DPLUS"=>
      ["[out]",
       "         DPLUS is REAL array, dimension (N)",
       "         The N diagonal elements of the diagonal matrix D(+)."],
     "LPLUS"=>
      ["[out]",
       "         LPLUS is REAL array, dimension (N-1)",
       "         The first (N-1) elements of LPLUS contain the subdiagonal",
       "         elements of the unit bidiagonal matrix L(+)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (2*N)",
       "         Workspace."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         Signals processing OK (=0) or failure (=1)"]}},
 "spbtrf"=>
  {"summary"=>
    ["SPBTRF computes the Cholesky factorization of a real symmetric",
     "positive definite band matrix A.",
     "The factorization has the form",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**T*U or A = L*L**T of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "zgehrd"=>
  {"summary"=>
    ["ZGEHRD reduces a complex general matrix A to upper Hessenberg form H by",
     "an unitary similarity transformation:  Q**H * A * Q = H ."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that A is already upper triangular in rows",
       "         and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "         set by a previous call to ZGEBAL; otherwise they should be",
       "         set to 1 and N respectively. See Further Details.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         elements below the first subdiagonal, with the array TAU,",
       "         represent the unitary matrix Q as a product of elementary",
       "         reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details). Elements 1:ILO-1 and IHI:N-1 of TAU are set to",
       "         zero."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,N).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "spprfs"=>
  {"summary"=>
    ["SPPRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric positive definite",
     "and packed, and provides error bounds and backward error estimates",
     "for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "AFP"=>
      ["[in]",
       "         AFP is REAL array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, as computed by SPPTRF/CPPTRF,",
       "         packed columnwise in a linear array in the same format as A",
       "         (see AP)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by SPPTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgesvxx"=>
  {"summary"=>
    ["   DGESVXX uses the LU factorization to compute the solution to a",
     "   double precision system of linear equations  A * X = B,  where A is an",
     "   N-by-N matrix and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. DGESVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   DGESVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   DGESVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what DGESVXX would itself produce."],
   "param"=>nil},
 "cpbequ"=>
  {"summary"=>
    ["CPBEQU computes row and column scalings intended to equilibrate a",
     "Hermitian positive definite band matrix A and reduce its condition",
     "number (with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular of A is stored;",
       "         = 'L':  Lower triangular of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The upper or lower triangle of the Hermitian band matrix A,",
       "         stored in the first KD+1 rows of the array.  The j-th column",
       "         of A is stored in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A.  LDAB >= KD+1."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is REAL",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "dsytrs_3"=>
  {"summary"=>
    ["DSYTRS_3 solves a system of linear equations A * X = B with a real",
     "symmetric matrix A using the factorization computed",
     "by DSYTRF_RK or DSYTRF_BK:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This algorithm is using Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**T)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**T)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by DSYTRF_RK and DSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF_RK or DSYTRF_BK."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgeqrt"=>
  {"summary"=>
    ["ZGEQRT computes a blocked QR factorization of a complex M-by-N matrix A",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.  MIN(M,N) >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if M >= N); the elements below the diagonal",
       "         are the columns of V."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,MIN(M,N))",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (NB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlaev2"=>
  {"summary"=>
    ["ZLAEV2 computes the eigendecomposition of a 2-by-2 Hermitian matrix",
     "   [  A         B  ]",
     "   [  CONJG(B)  C  ].",
     "On return, RT1 is the eigenvalue of larger absolute value, RT2 is the",
     "eigenvalue of smaller absolute value, and (CS1,SN1) is the unit right",
     "eigenvector for RT1, giving the decomposition",
     "[ CS1  CONJG(SN1) ] [    A     B ] [ CS1 -CONJG(SN1) ] = [ RT1  0  ]",
     "[-SN1     CS1     ] [ CONJG(B) C ] [ SN1     CS1     ]   [  0  RT2 ]."],
   "param"=>
    {"A"=>
      ["[in]",
       "         A is COMPLEX*16",
       "        The (1,1) element of the 2-by-2 matrix."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16",
       "        The (1,2) element and the conjugate of the (2,1) element of",
       "        the 2-by-2 matrix."],
     "C"=>
      ["[in]",
       "         C is COMPLEX*16",
       "        The (2,2) element of the 2-by-2 matrix."],
     "RT1"=>
      ["[out]",
       "         RT1 is DOUBLE PRECISION",
       "        The eigenvalue of larger absolute value."],
     "RT2"=>
      ["[out]",
       "         RT2 is DOUBLE PRECISION",
       "        The eigenvalue of smaller absolute value."],
     "CS1"=>["[out]", "         CS1 is DOUBLE PRECISION"],
     "SN1"=>
      ["[out]",
       "         SN1 is COMPLEX*16",
       "        The vector (CS1, SN1) is a unit right eigenvector for RT1."]}},
 "zpbcon"=>
  {"summary"=>
    ["ZPBCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex Hermitian positive definite band matrix using",
     "the Cholesky factorization A = U**H*U or A = L*L**H computed by",
     "ZPBTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor stored in AB;",
       "         = 'L':  Lower triangular factor stored in AB."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H of the band matrix A, stored in the",
       "         first KD+1 rows of the array.  The j-th column of U or L is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO ='U', AB(kd+1+i-j,j) = U(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO ='L', AB(1+i-j,j)    = L(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm (or infinity-norm) of the Hermitian band matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgeqr"=>
  {"summary"=>["SGEQR computes a QR factorization of an M-by-N matrix A."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R",
       "         (R is upper triangular if M >= N);",
       "         the elements below the diagonal are used to store part of the ",
       "         data structure to represent Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (MAX(5,TSIZE))",
       "         On exit, if INFO = 0, T(1) returns optimal (or either minimal ",
       "         or optimal, if query is assumed) TSIZE. See TSIZE for details.",
       "         Remaining T contains part of the data structure used to represent Q.",
       "         If one wants to apply or construct Q, then one needs to keep T ",
       "         (in addition to A) and pass it to further subroutines."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         If TSIZE >= 5, the dimension of the array T.",
       "         If TSIZE = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If TSIZE = -1, the routine calculates optimal size of T for the ",
       "         optimum performance and returns this value in T(1).",
       "         If TSIZE = -2, the routine calculates minimal size of T and ",
       "         returns this value in T(1)."],
     "WORK"=>
      ["[out]",
       "         (workspace) REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "strrfs"=>
  {"summary"=>
    ["STRRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular",
     "coefficient matrix.",
     "The solution matrix X must be computed by STRTRS or some other",
     "means before entering this routine.  STRRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dtprfs"=>
  {"summary"=>
    ["DTPRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular packed",
     "coefficient matrix.",
     "The solution matrix X must be computed by DTPTRS or some other",
     "means before entering this routine.  DTPRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgesvd"=>
  {"summary"=>
    ["SGESVD computes the singular value decomposition (SVD) of a real",
     "M-by-N matrix A, optionally computing the left and/or right singular",
     "vectors. The SVD is written",
     "     A = U * SIGMA * transpose(V)",
     "where SIGMA is an M-by-N matrix which is zero except for its",
     "min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and",
     "V is an N-by-N orthogonal matrix.  The diagonal elements of SIGMA",
     "are the singular values of A; they are real and non-negative, and",
     "are returned in descending order.  The first min(m,n) columns of",
     "U and V are the left and right singular vectors of A.",
     "Note that the routine returns V**T, not V."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'A':  all M columns of U are returned in array U:",
       "         = 'S':  the first min(m,n) columns of U (the left singular",
       "                 vectors) are returned in the array U;",
       "         = 'O':  the first min(m,n) columns of U (the left singular",
       "                 vectors) are overwritten on the array A;",
       "         = 'N':  no columns of U (no left singular vectors) are",
       "                 computed."],
     "JOBVT"=>
      ["[in]",
       "         JOBVT is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix",
       "         V**T:",
       "         = 'A':  all N rows of V**T are returned in the array VT;",
       "         = 'S':  the first min(m,n) rows of V**T (the right singular",
       "                 vectors) are returned in the array VT;",
       "         = 'O':  the first min(m,n) rows of V**T (the right singular",
       "                 vectors) are overwritten on the array A;",
       "         = 'N':  no rows of V**T (no right singular vectors) are",
       "                 computed.",
       "         JOBVT and JOBU cannot both be 'O'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if JOBU = 'O',  A is overwritten with the first min(m,n)",
       "                         columns of U (the left singular vectors,",
       "                         stored columnwise);",
       "         if JOBVT = 'O', A is overwritten with the first min(m,n)",
       "                         rows of V**T (the right singular vectors,",
       "                         stored rowwise);",
       "         if JOBU .ne. 'O' and JOBVT .ne. 'O', the contents of A",
       "                         are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is REAL array, dimension (LDU,UCOL)",
       "         (LDU,M) if JOBU = 'A' or (LDU,min(M,N)) if JOBU = 'S'.",
       "         If JOBU = 'A', U contains the M-by-M orthogonal matrix U;",
       "         if JOBU = 'S', U contains the first min(m,n) columns of U",
       "         (the left singular vectors, stored columnwise);",
       "         if JOBU = 'N' or 'O', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1; if",
       "         JOBU = 'S' or 'A', LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is REAL array, dimension (LDVT,N)",
       "         If JOBVT = 'A', VT contains the N-by-N orthogonal matrix",
       "         V**T;",
       "         if JOBVT = 'S', VT contains the first min(m,n) rows of",
       "         V**T (the right singular vectors, stored rowwise);",
       "         if JOBVT = 'N' or 'O', VT is not referenced."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1; if",
       "         JOBVT = 'A', LDVT >= N; if JOBVT = 'S', LDVT >= min(M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK;",
       "         if INFO > 0, WORK(2:MIN(M,N)) contains the unconverged",
       "         superdiagonal elements of an upper bidiagonal matrix B",
       "         whose diagonal is in S (not necessarily sorted). B",
       "         satisfies A = U * B * VT, so it has the same singular values",
       "         as A, and singular vectors related by U and VT."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >= MAX(1,5*MIN(M,N)) for the paths (see comments inside code):",
       "            - PATH 1  (M much larger than N, JOBU='N')",
       "            - PATH 1t (N much larger than M, JOBVT='N')",
       "         LWORK >= MAX(1,3*MIN(M,N)+MAX(M,N),5*MIN(M,N)) for the other paths",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if SBDSQR did not converge, INFO specifies how many",
       "               superdiagonals of an intermediate bidiagonal form B",
       "               did not converge to zero. See the description of WORK",
       "               above for details."]}},
 "dpbtrs"=>
  {"summary"=>
    ["DPBTRS solves a system of linear equations A*X = B with a symmetric",
     "positive definite band matrix A using the Cholesky factorization",
     "A = U**T*U or A = L*L**T computed by DPBTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor stored in AB;",
       "         = 'L':  Lower triangular factor stored in AB."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T of the band matrix A, stored in the",
       "         first KD+1 rows of the array.  The j-th column of U or L is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO ='U', AB(kd+1+i-j,j) = U(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO ='L', AB(1+i-j,j)    = L(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ssbev_2stage"=>
  {"summary"=>
    ["SSBEV_2STAGE computes all the eigenvalues and, optionally, eigenvectors of",
     "a real symmetric band matrix A using the 2stage technique for",
     "the reduction to tridiagonal."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension LWORK",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS + N",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "zpoequ"=>
  {"summary"=>
    ["ZPOEQU computes row and column scalings intended to equilibrate a",
     "Hermitian positive definite matrix A and reduce its condition number",
     "(with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The N-by-N Hermitian positive definite matrix whose scaling",
       "         factors are to be computed.  Only the diagonal elements of A",
       "         are referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is DOUBLE PRECISION",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "ilaenv"=>
  {"summary"=>
    ["ILAENV is called from the LAPACK routines to choose problem-dependent",
     "parameters for the local environment.  See ISPEC for a description of",
     "the parameters.",
     "ILAENV returns an INTEGER",
     "if ILAENV >= 0: ILAENV returns the value of the parameter specified by ISPEC",
     "if ILAENV < 0:  if ILAENV = -k, the k-th argument had an illegal value.",
     "This version provides a set of parameters which should give good,",
     "but not optimal, performance on many of the currently available",
     "computers.  Users are encouraged to modify this subroutine to set",
     "the tuning parameters for their particular machine using the option",
     "and problem size information in the arguments.",
     "This routine will not function correctly if it is converted to all",
     "lower case.  Converting it to all upper case is allowed."],
   "param"=>
    {"ISPEC"=>
      ["[in]",
       "         ISPEC is INTEGER",
       "         Specifies the parameter to be returned as the value of",
       "         ILAENV.",
       "         = 1: the optimal blocksize; if this value is 1, an unblocked",
       "              algorithm will give the best performance.",
       "         = 2: the minimum block size for which the block routine",
       "              should be used; if the usable block size is less than",
       "              this value, an unblocked routine should be used.",
       "         = 3: the crossover point (in a block routine, for N less",
       "              than this value, an unblocked routine should be used)",
       "         = 4: the number of shifts, used in the nonsymmetric",
       "              eigenvalue routines (DEPRECATED)",
       "         = 5: the minimum column dimension for blocking to be used;",
       "              rectangular blocks must have dimension at least k by m,",
       "              where k is given by ILAENV(2,...) and m by ILAENV(5,...)",
       "         = 6: the crossover point for the SVD (when reducing an m by n",
       "              matrix to bidiagonal form, if max(m,n)/min(m,n) exceeds",
       "              this value, a QR factorization is used first to reduce",
       "              the matrix to a triangular form.)",
       "         = 7: the number of processors",
       "         = 8: the crossover point for the multishift QR method",
       "              for nonsymmetric eigenvalue problems (DEPRECATED)",
       "         = 9: maximum size of the subproblems at the bottom of the",
       "              computation tree in the divide-and-conquer algorithm",
       "              (used by xGELSD and xGESDD)",
       "         =10: ieee NaN arithmetic can be trusted not to trap",
       "         =11: infinity arithmetic can be trusted not to trap",
       "         12 <= ISPEC <= 16:",
       "              xHSEQR or related subroutines,",
       "              see IPARMQ for detailed explanation"],
     "NAME"=>
      ["[in]",
       "         NAME is CHARACTER*(*)",
       "         The name of the calling subroutine, in either upper case or",
       "         lower case."],
     "OPTS"=>
      ["[in]",
       "         OPTS is CHARACTER*(*)",
       "         The character options to the subroutine NAME, concatenated",
       "         into a single character string.  For example, UPLO = 'U',",
       "         TRANS = 'T', and DIAG = 'N' for a triangular routine would",
       "         be specified as OPTS = 'UTN'."],
     "N1"=>["[in]", "         N1 is INTEGER"],
     "N2"=>["[in]", "         N2 is INTEGER"],
     "N3"=>["[in]", "         N3 is INTEGER"],
     "N4"=>
      ["[in]",
       "         N4 is INTEGER",
       "         Problem dimensions for the subroutine NAME; these may not all",
       "         be required."]}},
 "zsysv_aa"=>
  {"summary"=>
    ["ZSYSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "Aasen's algorithm is used to factor A as",
     "   A = U * T * U**T,  if UPLO = 'U', or",
     "   A = L * T * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is symmetric tridiagonal. The factored",
     "form of A is then used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the tridiagonal matrix T and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*T*U**T or A = L*T*L**T as computed by",
       "         ZSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= MAX(1,2*N,3*N-2), and for",
       "         the best performance, LWORK >= MAX(1,N*NB), where NB is",
       "         the optimal blocksize for ZSYTRF_AA.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "chetri"=>
  {"summary"=>
    ["CHETRI computes the inverse of a complex Hermitian indefinite matrix",
     "A using the factorization A = U*D*U**H or A = L*D*L**H computed by",
     "CHETRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CHETRF.",
       "         On exit, if INFO = 0, the (Hermitian) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "clarfgp"=>
  {"summary"=>
    ["CLARFGP generates a complex elementary reflector H of order n, such",
     "that",
     "      H**H * ( alpha ) = ( beta ),   H**H * H = I.",
     "             (   x   )   (   0  )",
     "where alpha and beta are scalars, beta is real and non-negative, and",
     "x is an (n-1)-element complex vector.  H is represented in the form",
     "      H = I - tau * ( 1 ) * ( 1 v**H ) ,",
     "                    ( v )",
     "where tau is a complex scalar and v is a complex (n-1)-element",
     "vector. Note that H is not hermitian.",
     "If the elements of x are all zero and alpha is real, then tau = 0",
     "and H is taken to be the unit matrix."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the elementary reflector."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is COMPLEX",
       "         On entry, the value alpha.",
       "         On exit, it is overwritten with the value beta."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension",
       "                        (1+(N-2)*abs(INCX))",
       "         On entry, the vector x.",
       "         On exit, it is overwritten with the vector v."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "TAU"=>["[out]", "         TAU is COMPLEX", "         The value tau."]}},
 "clahef_rook"=>
  {"summary"=>
    ["CLAHEF_ROOK computes a partial factorization of a complex Hermitian",
     "matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting",
     "method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I      0     )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**H U22**H )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**H L21**H )  if UPLO = 'L'",
     "      ( L21  I ) (  0  A22 ) (  0      I     )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "Note that U**H denotes the conjugate transpose of U.",
     "CLAHEF_ROOK is an auxiliary routine called by CHETRF_ROOK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "W"=>["[out]", "         W is COMPLEX array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "sgghd3"=>
  {"summary"=>
    ["SGGHD3 reduces a pair of real matrices (A,B) to generalized upper",
     "Hessenberg form using orthogonal transformations, where A is a",
     "general matrix and B is upper triangular.  The form of the",
     "generalized eigenvalue problem is",
     "   A*x = lambda*B*x,",
     "and B is typically made upper triangular by computing its QR",
     "factorization and moving the orthogonal matrix Q to the left side",
     "of the equation.",
     "This subroutine simultaneously reduces A to a Hessenberg matrix H:",
     "   Q**T*A*Z = H",
     "and transforms B to another upper triangular matrix T:",
     "   Q**T*B*Z = T",
     "in order to reduce the problem to its standard form",
     "   H*y = lambda*T*y",
     "where y = Z**T*x.",
     "The orthogonal matrices Q and Z are determined as products of Givens",
     "rotations.  They may either be formed explicitly, or they may be",
     "postmultiplied into input matrices Q1 and Z1, so that",
     "     Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T",
     "     Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T",
     "If Q1 is the orthogonal matrix from the QR factorization of B in the",
     "original equation A*x = lambda*B*x, then SGGHD3 reduces the original",
     "problem to generalized Hessenberg form.",
     "This is a blocked variant of SGGHRD, using matrix-matrix",
     "multiplications for parts of the computation to enhance performance."],
   "param"=>
    {"COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': do not compute Q;",
       "         = 'I': Q is initialized to the unit matrix, and the",
       "                orthogonal matrix Q is returned;",
       "         = 'V': Q must contain an orthogonal matrix Q1 on entry,",
       "                and the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': do not compute Z;",
       "         = 'I': Z is initialized to the unit matrix, and the",
       "                orthogonal matrix Z is returned;",
       "         = 'V': Z must contain an orthogonal matrix Z1 on entry,",
       "                and the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of A which are to be",
       "         reduced.  It is assumed that A is already upper triangular",
       "         in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are",
       "         normally set by a previous call to SGGBAL; otherwise they",
       "         should be set to 1 and N respectively.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the N-by-N general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         rest is set to zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, the N-by-N upper triangular matrix B.",
       "         On exit, the upper triangular matrix T = Q**T B Z.  The",
       "         elements below the diagonal are set to zero."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the orthogonal matrix Q1,",
       "         typically from the QR factorization of B.",
       "         On exit, if COMPQ='I', the orthogonal matrix Q, and if",
       "         COMPQ = 'V', the product Q1*Q.",
       "         Not referenced if COMPQ='N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the orthogonal matrix Z1.",
       "         On exit, if COMPZ='I', the orthogonal matrix Z, and if",
       "         COMPZ = 'V', the product Z1*Z.",
       "         Not referenced if COMPZ='N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.",
       "         LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= 1.",
       "         For optimum performance LWORK >= 6*N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "clatrd"=>
  {"summary"=>
    ["CLATRD reduces NB rows and columns of a complex Hermitian matrix A to",
     "Hermitian tridiagonal form by a unitary similarity",
     "transformation Q**H * A * Q, and returns the matrices V and W which are",
     "needed to apply the transformation to the unreduced part of A.",
     "If UPLO = 'U', CLATRD reduces the last NB rows and columns of a",
     "matrix, of which the upper triangle is supplied;",
     "if UPLO = 'L', CLATRD reduces the first NB rows and columns of a",
     "matrix, of which the lower triangle is supplied.",
     "This is an auxiliary routine called by CHETRD."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U': Upper triangular",
       "         = 'L': Lower triangular"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of rows and columns to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit:",
       "         if UPLO = 'U', the last NB columns have been reduced to",
       "           tridiagonal form, with the diagonal elements overwriting",
       "           the diagonal elements of A; the elements above the diagonal",
       "           with the array TAU, represent the unitary matrix Q as a",
       "           product of elementary reflectors;",
       "         if UPLO = 'L', the first NB columns have been reduced to",
       "           tridiagonal form, with the diagonal elements overwriting",
       "           the diagonal elements of A; the elements below the diagonal",
       "           with the array TAU, represent the  unitary matrix Q as a",
       "           product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         If UPLO = 'U', E(n-nb:n-1) contains the superdiagonal",
       "         elements of the last NB columns of the reduced matrix;",
       "         if UPLO = 'L', E(1:nb) contains the subdiagonal elements of",
       "         the first NB columns of the reduced matrix."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors, stored in",
       "         TAU(n-nb:n-1) if UPLO = 'U', and in TAU(1:nb) if UPLO = 'L'.",
       "         See Further Details."],
     "W"=>
      ["[out]",
       "         W is COMPLEX array, dimension (LDW,NB)",
       "         The n-by-nb matrix W required to update the unreduced part",
       "         of A."],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W. LDW >= max(1,N)."]}},
 "cunmrq"=>
  {"summary"=>
    ["CUNMRQ overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1)**H H(2)**H . . . H(k)**H",
     "as returned by CGERQF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGERQF in the last k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGERQF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "strevc"=>
  {"summary"=>
    ["STREVC computes some or all of the right and/or left eigenvectors of",
     "a real upper quasi-triangular matrix T.",
     "Matrices of this type are produced by the Schur factorization of",
     "a real general matrix:  A = Q*T*Q**T, as computed by SHSEQR.",
     "The right eigenvector x and the left eigenvector y of T corresponding",
     "to an eigenvalue w are defined by:",
     "   T*x = w*x,     (y**H)*T = w*(y**H)",
     "where y**H denotes the conjugate transpose of y.",
     "The eigenvalues are not input to this routine, but are read directly",
     "from the diagonal blocks of T.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an",
     "input matrix.  If Q is the orthogonal factor that reduces a matrix",
     "A to Schur form T, then Q*X and Q*Y are the matrices of right and",
     "left eigenvectors of A."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  compute right eigenvectors only;",
       "         = 'L':  compute left eigenvectors only;",
       "         = 'B':  compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A':  compute all right and/or left eigenvectors;",
       "         = 'B':  compute all right and/or left eigenvectors,",
       "                 backtransformed by the matrices in VR and/or VL;",
       "         = 'S':  compute selected right and/or left eigenvectors,",
       "                 as indicated by the logical array SELECT."],
     "SELECT"=>
      ["[in,out]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenvectors to be",
       "         computed.",
       "         If w(j) is a real eigenvalue, the corresponding real",
       "         eigenvector is computed if SELECT(j) is .TRUE..",
       "         If w(j) and w(j+1) are the real and imaginary parts of a",
       "         complex eigenvalue, the corresponding complex eigenvector is",
       "         computed if either SELECT(j) or SELECT(j+1) is .TRUE., and",
       "         on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is set to",
       "         .FALSE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (LDT,N)",
       "         The upper quasi-triangular matrix T in Schur canonical form."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is REAL array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the orthogonal matrix Q",
       "         of Schur vectors returned by SHSEQR).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VL, in the same order as their",
       "                          eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part, and the second the imaginary part.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1, and if",
       "         SIDE = 'L' or 'B', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is REAL array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Q (usually the orthogonal matrix Q",
       "         of Schur vectors returned by SHSEQR).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*X;",
       "         if HOWMNY = 'S', the right eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VR, in the same order as their",
       "                          eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part and the second the imaginary part.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1, and if",
       "         SIDE = 'R' or 'B', LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.",
       "         If HOWMNY = 'A' or 'B', M is set to N.",
       "         Each selected real eigenvector occupies one column and each",
       "         selected complex eigenvector occupies two columns."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dggev"=>
  {"summary"=>
    ["DGGEV computes for a pair of N-by-N real nonsymmetric matrices (A,B)",
     "the generalized eigenvalues, and optionally, the left and/or right",
     "generalized eigenvectors.",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right eigenvector v(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 A * v(j) = lambda(j) * B * v(j).",
     "The left eigenvector u(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 u(j)**H * A  = lambda(j) * u(j)**H * B .",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHAR"=>
      ["[out]", "         ALPHAR is DOUBLE PRECISION array, dimension (N)"],
     "ALPHAI"=>
      ["[out]", "         ALPHAI is DOUBLE PRECISION array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  If ALPHAI(j) is zero, then",
       "         the j-th eigenvalue is real; if positive, then the j-th and",
       "         (j+1)-st eigenvalues are a complex conjugate pair, with",
       "         ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio",
       "         alpha/beta.  However, ALPHAR and ALPHAI will be always less",
       "         than and usually comparable with norm(A) in magnitude, and",
       "         BETA always less than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is DOUBLE PRECISION array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         u(j) = VL(:,j), the j-th column of VL. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         u(j) = VL(:,j)+i*VL(:,j+1) and u(j+1) = VL(:,j)-i*VL(:,j+1).",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part)+abs(imag. part)=1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is DOUBLE PRECISION array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         v(j) = VR(:,j), the j-th column of VR. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1).",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part)+abs(imag. part)=1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,8*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHAR(j), ALPHAI(j), and BETA(j)",
       "               should be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in DHGEQZ.",
       "               =N+2: error return from DTGEVC."]}},
 "slag2"=>
  {"summary"=>
    ["SLAG2 computes the eigenvalues of a 2 x 2 generalized eigenvalue",
     "problem  A - w B, with scaling as necessary to avoid over-/underflow.",
     "The scaling factor \"s\" results in a modified eigenvalue equation",
     "    s A - w B",
     "where  s  is a non-negative scaling factor chosen so that  w,  w B,",
     "and  s A  do not overflow and, if possible, do not underflow, either."],
   "param"=>
    {"A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA, 2)",
       "         On entry, the 2 x 2 matrix A.  It is assumed that its 1-norm",
       "         is less than 1/SAFMIN.  Entries less than",
       "         sqrt(SAFMIN)*norm(A) are subject to being treated as zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= 2."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB, 2)",
       "         On entry, the 2 x 2 upper triangular matrix B.  It is",
       "         assumed that the one-norm of B is less than 1/SAFMIN.  The",
       "         diagonals should be at least sqrt(SAFMIN) times the largest",
       "         element of B (in absolute value); if a diagonal is smaller",
       "         than that, then  +/- sqrt(SAFMIN) will be used instead of",
       "         that diagonal."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= 2."],
     "SAFMIN"=>
      ["[in]",
       "         SAFMIN is REAL",
       "         The smallest positive number s.t. 1/SAFMIN does not",
       "         overflow.  (This should always be SLAMCH('S') -- it is an",
       "         argument in order to avoid having to call SLAMCH frequently.)"],
     "SCALE1"=>
      ["[out]",
       "         SCALE1 is REAL",
       "         A scaling factor used to avoid over-/underflow in the",
       "         eigenvalue equation which defines the first eigenvalue.  If",
       "         the eigenvalues are complex, then the eigenvalues are",
       "         ( WR1  +/-  WI i ) / SCALE1  (which may lie outside the",
       "         exponent range of the machine), SCALE1=SCALE2, and SCALE1",
       "         will always be positive.  If the eigenvalues are real, then",
       "         the first (real) eigenvalue is  WR1 / SCALE1 , but this may",
       "         overflow or underflow, and in fact, SCALE1 may be zero or",
       "         less than the underflow threshold if the exact eigenvalue",
       "         is sufficiently large."],
     "SCALE2"=>
      ["[out]",
       "         SCALE2 is REAL",
       "         A scaling factor used to avoid over-/underflow in the",
       "         eigenvalue equation which defines the second eigenvalue.  If",
       "         the eigenvalues are complex, then SCALE2=SCALE1.  If the",
       "         eigenvalues are real, then the second (real) eigenvalue is",
       "         WR2 / SCALE2 , but this may overflow or underflow, and in",
       "         fact, SCALE2 may be zero or less than the underflow",
       "         threshold if the exact eigenvalue is sufficiently large."],
     "WR1"=>
      ["[out]",
       "         WR1 is REAL",
       "         If the eigenvalue is real, then WR1 is SCALE1 times the",
       "         eigenvalue closest to the (2,2) element of A B**(-1).  If the",
       "         eigenvalue is complex, then WR1=WR2 is SCALE1 times the real",
       "         part of the eigenvalues."],
     "WR2"=>
      ["[out]",
       "         WR2 is REAL",
       "         If the eigenvalue is real, then WR2 is SCALE2 times the",
       "         other eigenvalue.  If the eigenvalue is complex, then",
       "         WR1=WR2 is SCALE1 times the real part of the eigenvalues."],
     "WI"=>
      ["[out]",
       "         WI is REAL",
       "         If the eigenvalue is real, then WI is zero.  If the",
       "         eigenvalue is complex, then WI is SCALE1 times the imaginary",
       "         part of the eigenvalues.  WI will always be non-negative."]}},
 "dgesvj"=>
  {"summary"=>
    ["DGESVJ computes the singular value decomposition (SVD) of a real",
     "M-by-N matrix A, where M >= N. The SVD of A is written as",
     "                                   [++]   [xx]   [x0]   [xx]",
     "             A = U * SIGMA * V^t,  [++] = [xx] * [ox] * [xx]",
     "                                   [++]   [xx]",
     "where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal",
     "matrix, and V is an N-by-N orthogonal matrix. The diagonal elements",
     "of SIGMA are the singular values of A. The columns of U and V are the",
     "left and the right singular vectors of A, respectively.",
     "DGESVJ can sometimes compute tiny singular values and their singular vectors much",
     "more accurately than other SVD routines, see below under Further Details."],
   "param"=>
    {"JOBA"=>
      ["[in]",
       "         JOBA is CHARACTER* 1",
       "         Specifies the structure of A.",
       "         = 'L': The input matrix A is lower triangular;",
       "         = 'U': The input matrix A is upper triangular;",
       "         = 'G': The input matrix A is general M-by-N matrix, M >= N."],
     "JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies whether to compute the left singular vectors",
       "         (columns of U):",
       "         = 'U': The left singular vectors corresponding to the nonzero",
       "                singular values are computed and returned in the leading",
       "                columns of A. See more details in the description of A.",
       "                The default numerical orthogonality threshold is set to",
       "                approximately TOL=CTOL*EPS, CTOL=DSQRT(M), EPS=DLAMCH('E').",
       "         = 'C': Analogous to JOBU='U', except that user can control the",
       "                level of numerical orthogonality of the computed left",
       "                singular vectors. TOL can be set to TOL = CTOL*EPS, where",
       "                CTOL is given on input in the array WORK.",
       "                No CTOL smaller than ONE is allowed. CTOL greater",
       "                than 1 / EPS is meaningless. The option 'C'",
       "                can be used if M*EPS is satisfactory orthogonality",
       "                of the computed left singular vectors, so CTOL=M could",
       "                save few sweeps of Jacobi rotations.",
       "                See the descriptions of A and WORK(1).",
       "         = 'N': The matrix U is not computed. However, see the",
       "                description of A."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether to compute the right singular vectors, that",
       "         is, the matrix V:",
       "         = 'V' : the matrix V is computed and returned in the array V",
       "         = 'A' : the Jacobi rotations are applied to the MV-by-N",
       "                 array V. In other words, the right singular vector",
       "                 matrix V is not computed explicitly, instead it is",
       "                 applied to an MV-by-N matrix initially stored in the",
       "                 first MV rows of V.",
       "         = 'N' : the matrix V is not computed and the array V is not",
       "                 referenced"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A. 1/DLAMCH('E') > M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit :",
       "         If JOBU .EQ. 'U' .OR. JOBU .EQ. 'C' :",
       "                If INFO .EQ. 0 :",
       "                RANKA orthonormal columns of U are returned in the",
       "                leading RANKA columns of the array A. Here RANKA <= N",
       "                is the number of computed singular values of A that are",
       "                above the underflow threshold DLAMCH('S'). The singular",
       "                vectors corresponding to underflowed or zero singular",
       "                values are not computed. The value of RANKA is returned",
       "                in the array WORK as RANKA=NINT(WORK(2)). Also see the",
       "                descriptions of SVA and WORK. The computed columns of U",
       "                are mutually numerically orthogonal up to approximately",
       "                TOL=DSQRT(M)*EPS (default); or TOL=CTOL*EPS (JOBU.EQ.'C'),",
       "                see the description of JOBU.",
       "                If INFO .GT. 0 :",
       "                the procedure DGESVJ did not converge in the given number",
       "                of iterations (sweeps). In that case, the computed",
       "                columns of U may not be orthogonal up to TOL. The output",
       "                U (stored in A), SIGMA (given by the computed singular",
       "                values in SVA(1:N)) and V is still a decomposition of the",
       "                input matrix A in the sense that the residual",
       "                ||A-SCALE*U*SIGMA*V^T||_2 / ||A||_2 is small.",
       "         If JOBU .EQ. 'N' :",
       "                If INFO .EQ. 0 :",
       "                Note that the left singular vectors are 'for free' in the",
       "                one-sided Jacobi SVD algorithm. However, if only the",
       "                singular values are needed, the level of numerical",
       "                orthogonality of U is not an issue and iterations are",
       "                stopped when the columns of the iterated matrix are",
       "                numerically orthogonal up to approximately M*EPS. Thus,",
       "                on exit, A contains the columns of U scaled with the",
       "                corresponding singular values.",
       "                If INFO .GT. 0 :",
       "                the procedure DGESVJ did not converge in the given number",
       "                of iterations (sweeps)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "SVA"=>
      ["[out]",
       "         SVA is DOUBLE PRECISION array, dimension (N)",
       "         On exit :",
       "         If INFO .EQ. 0 :",
       "         depending on the value SCALE = WORK(1), we have:",
       "                If SCALE .EQ. ONE :",
       "                SVA(1:N) contains the computed singular values of A.",
       "                During the computation SVA contains the Euclidean column",
       "                norms of the iterated matrices in the array A.",
       "                If SCALE .NE. ONE :",
       "                The singular values of A are SCALE*SVA(1:N), and this",
       "                factored representation is due to the fact that some of the",
       "                singular values of A might underflow or overflow.",
       "         If INFO .GT. 0 :",
       "         the procedure DGESVJ did not converge in the given number of",
       "         iterations (sweeps) and SCALE*SVA(1:N) may not be accurate."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then the product of Jacobi rotations in DGESVJ",
       "         is applied to the first MV rows of V. See the description of JOBV."],
     "V"=>
      ["[in,out]",
       "         V is DOUBLE PRECISION array, dimension (LDV,N)",
       "         If JOBV = 'V', then V contains on exit the N-by-N matrix of",
       "                        the right singular vectors;",
       "         If JOBV = 'A', then V contains the product of the computed right",
       "                        singular vector matrix and the initial matrix in",
       "                        the array V.",
       "         If JOBV = 'N', then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V, LDV .GE. 1.",
       "         If JOBV .EQ. 'V', then LDV .GE. max(1,N).",
       "         If JOBV .EQ. 'A', then LDV .GE. max(1,MV) ."],
     "WORK"=>
      ["[in,out]",
       "         WORK is DOUBLE PRECISION array, dimension MAX(6,M+N).",
       "         On entry :",
       "         If JOBU .EQ. 'C' :",
       "         WORK(1) = CTOL, where CTOL defines the threshold for convergence.",
       "                   The process stops if all columns of A are mutually",
       "                   orthogonal up to CTOL*EPS, EPS=DLAMCH('E').",
       "                   It is required that CTOL >= ONE, i.e. it is not",
       "                   allowed to force the routine to obtain orthogonality",
       "                   below EPS.",
       "         On exit :",
       "         WORK(1) = SCALE is the scaling factor such that SCALE*SVA(1:N)",
       "                   are the computed singular values of A.",
       "                   (See description of SVA().)",
       "         WORK(2) = NINT(WORK(2)) is the number of the computed nonzero",
       "                   singular values.",
       "         WORK(3) = NINT(WORK(3)) is the number of the computed singular",
       "                   values that are larger than the underflow threshold.",
       "         WORK(4) = NINT(WORK(4)) is the number of sweeps of Jacobi",
       "                   rotations needed for numerical convergence.",
       "         WORK(5) = max_{i.NE.j} |COS(A(:,i),A(:,j))| in the last sweep.",
       "                   This is useful information in cases when DGESVJ did",
       "                   not converge, as it can be used to estimate whether",
       "                   the output is stil useful and for post festum analysis.",
       "         WORK(6) = the largest absolute value over all sines of the",
       "                   Jacobi rotation angles in the last sweep. It can be",
       "                   useful for a post festum analysis."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         length of WORK, WORK >= MAX(6,M+N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value",
       "         > 0 : DGESVJ did not converge in the maximal allowed number (30)",
       "               of sweeps. The output may still be useful. See the",
       "               description of WORK."]}},
 "dpoequ"=>
  {"summary"=>
    ["DPOEQU computes row and column scalings intended to equilibrate a",
     "symmetric positive definite matrix A and reduce its condition number",
     "(with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The N-by-N symmetric positive definite matrix whose scaling",
       "         factors are to be computed.  Only the diagonal elements of A",
       "         are referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is DOUBLE PRECISION",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "clantp"=>
  {"summary"=>
    ["CLANTP  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "triangular matrix A, supplied in packed form.",
     "   CLANTP = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANTP as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANTP is",
       "         set to zero."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         Note that when DIAG = 'U', the elements of the array AP",
       "         corresponding to the diagonal elements of the matrix A are",
       "         not referenced, but are assumed to be one."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "zggevx"=>
  {"summary"=>
    ["ZGGEVX computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B) the generalized eigenvalues, and optionally, the left and/or",
     "right generalized eigenvectors.",
     "Optionally, it also computes a balancing transformation to improve",
     "the conditioning of the eigenvalues and eigenvectors (ILO, IHI,",
     "LSCALE, RSCALE, ABNRM, and BBNRM), reciprocal condition numbers for",
     "the eigenvalues (RCONDE), and reciprocal condition numbers for the",
     "right eigenvectors (RCONDV).",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right eigenvector v(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 A * v(j) = lambda(j) * B * v(j) .",
     "The left eigenvector u(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 u(j)**H * A  = lambda(j) * u(j)**H * B.",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"BALANC"=>
      ["[in]",
       "         BALANC is CHARACTER*1",
       "         Specifies the balance option to be performed:",
       "         = 'N':  do not diagonally scale or permute;",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale.",
       "         Computed reciprocal condition numbers will be for the",
       "         matrices after permuting and/or balancing. Permuting does",
       "         not change condition numbers (in exact arithmetic), but",
       "         balancing does."],
     "JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': none are computed;",
       "         = 'E': computed for eigenvalues only;",
       "         = 'V': computed for eigenvectors only;",
       "         = 'B': computed for eigenvalues and eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten. If JOBVL='V' or JOBVR='V'",
       "         or both, then A contains the first part of the complex Schur",
       "         form of the \"balanced\" versions of the input A and B."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten. If JOBVL='V' or JOBVR='V'",
       "         or both, then B contains the second part of the complex",
       "         Schur form of the \"balanced\" versions of the input A and B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX*16 array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX*16 array, dimension (N)",
       "         On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the generalized",
       "         eigenvalues.",
       "         Note: the quotient ALPHA(j)/BETA(j) ) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio ALPHA/BETA.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is COMPLEX*16 array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left generalized eigenvectors u(j) are",
       "         stored one after another in the columns of VL, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector will be scaled so the largest component",
       "         will have abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is COMPLEX*16 array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right generalized eigenvectors v(j) are",
       "         stored one after another in the columns of VR, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector will be scaled so the largest component",
       "         will have abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are integer values such that on exit",
       "         A(i,j) = 0 and B(i,j) = 0 if i > j and",
       "         j = 1,...,ILO-1 or i = IHI+1,...,N.",
       "         If BALANC = 'N' or 'S', ILO = 1 and IHI = N."],
     "LSCALE"=>
      ["[out]",
       "         LSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the left side of A and B.  If PL(j) is the index of the",
       "         row interchanged with row j, and DL(j) is the scaling",
       "         factor applied to row j, then",
       "           LSCALE(j) = PL(j)  for j = 1,...,ILO-1",
       "                     = DL(j)  for j = ILO,...,IHI",
       "                     = PL(j)  for j = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "RSCALE"=>
      ["[out]",
       "         RSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the right side of A and B.  If PR(j) is the index of the",
       "         column interchanged with column j, and DR(j) is the scaling",
       "         factor applied to column j, then",
       "           RSCALE(j) = PR(j)  for j = 1,...,ILO-1",
       "                     = DR(j)  for j = ILO,...,IHI",
       "                     = PR(j)  for j = IHI+1,...,N",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "ABNRM"=>
      ["[out]",
       "         ABNRM is DOUBLE PRECISION",
       "         The one-norm of the balanced matrix A."],
     "BBNRM"=>
      ["[out]",
       "         BBNRM is DOUBLE PRECISION",
       "         The one-norm of the balanced matrix B."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is DOUBLE PRECISION array, dimension (N)",
       "         If SENSE = 'E' or 'B', the reciprocal condition numbers of",
       "         the eigenvalues, stored in consecutive elements of the array.",
       "         If SENSE = 'N' or 'V', RCONDE is not referenced."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is DOUBLE PRECISION array, dimension (N)",
       "         If JOB = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the eigenvectors, stored in consecutive elements",
       "         of the array. If the eigenvalues cannot be reordered to",
       "         compute RCONDV(j), RCONDV(j) is set to 0; this can only occur",
       "         when the true value would be very small anyway.",
       "         If SENSE = 'N' or 'E', RCONDV is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,2*N).",
       "         If SENSE = 'E', LWORK >= max(1,4*N).",
       "         If SENSE = 'V' or 'B', LWORK >= max(1,2*N*N+2*N).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (lrwork)",
       "         lrwork must be at least max(1,6*N) if BALANC = 'S' or 'B',",
       "         and at least max(1,2*N) otherwise.",
       "         Real workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N+2)",
       "         If SENSE = 'E', IWORK is not referenced."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         If SENSE = 'N', BWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHA(j) and BETA(j) should be correct",
       "               for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in ZHGEQZ.",
       "               =N+2: error return from ZTGEVC."]}},
 "zposvx"=>
  {"summary"=>
    ["ZPOSVX uses the Cholesky factorization A = U**H*U or A = L*L**H to",
     "compute the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite matrix and X and B",
     "are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "slamrg"=>
  {"summary"=>
    ["SLAMRG will create a permutation list which will merge the elements",
     "of A (which is composed of two independently sorted sets) into a",
     "single set which is sorted in ascending order."],
   "param"=>
    {"N1"=>["[in]", "         N1 is INTEGER"],
     "N2"=>
      ["[in]",
       "         N2 is INTEGER",
       "        These arguments contain the respective lengths of the two",
       "        sorted lists to be merged."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (N1+N2)",
       "        The first N1 elements of A contain a list of numbers which",
       "        are sorted in either ascending or descending order.  Likewise",
       "        for the final N2 elements."],
     "STRD1"=>["[in]", "         STRD1 is INTEGER"],
     "STRD2"=>
      ["[in]",
       "         STRD2 is INTEGER",
       "        These are the strides to be taken through the array A.",
       "        Allowable strides are 1 and -1.  They indicate whether a",
       "        subset of A is sorted in ascending (STRDx = 1) or descending",
       "        (STRDx = -1) order."],
     "INDEX"=>
      ["[out]",
       "         INDEX is INTEGER array, dimension (N1+N2)",
       "        On exit this array will contain a permutation such that",
       "        if B( I ) = A( INDEX( I ) ) for I=1,N1+N2, then B will be",
       "        sorted in ascending order."]}},
 "claein"=>
  {"summary"=>
    ["CLAEIN uses inverse iteration to find a right or left eigenvector",
     "corresponding to the eigenvalue W of a complex upper Hessenberg",
     "matrix H."],
   "param"=>
    {"RIGHTV"=>
      ["[in]",
       "         RIGHTV is LOGICAL",
       "         = .TRUE. : compute right eigenvector;",
       "         = .FALSE.: compute left eigenvector."],
     "NOINIT"=>
      ["[in]",
       "         NOINIT is LOGICAL",
       "         = .TRUE. : no initial vector supplied in V",
       "         = .FALSE.: initial vector supplied in V."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "H"=>
      ["[in]",
       "         H is COMPLEX array, dimension (LDH,N)",
       "         The upper Hessenberg matrix H."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max(1,N)."],
     "W"=>
      ["[in]",
       "         W is COMPLEX",
       "         The eigenvalue of H whose corresponding right or left",
       "         eigenvector is to be computed."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX array, dimension (N)",
       "         On entry, if NOINIT = .FALSE., V must contain a starting",
       "         vector for inverse iteration; otherwise V need not be set.",
       "         On exit, V contains the computed eigenvector, normalized so",
       "         that the component of largest magnitude has magnitude 1; here",
       "         the magnitude of a complex number (x,y) is taken to be",
       "         |x| + |y|."],
     "B"=>["[out]", "         B is COMPLEX array, dimension (LDB,N)"],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "EPS3"=>
      ["[in]",
       "         EPS3 is REAL",
       "         A small machine-dependent value which is used to perturb",
       "         close eigenvalues, and to replace zero pivots."],
     "SMLNUM"=>
      ["[in]",
       "         SMLNUM is REAL",
       "         A machine-dependent value close to the underflow threshold."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         = 1:  inverse iteration did not converge; V is set to the",
       "               last iterate."]}},
 "dtfttr"=>
  {"summary"=>
    ["DTFTTR copies a triangular matrix A from rectangular full packed",
     "format (TF) to standard full format (TR)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF is in Normal format;",
       "         = 'T':  ARF is in Transpose format."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices ARF and A. N >= 0."],
     "ARF"=>
      ["[in]",
       "         ARF is DOUBLE PRECISION array, dimension (N*(N+1)/2).",
       "         On entry, the upper (if UPLO = 'U') or lower (if UPLO = 'L')",
       "         matrix A in RFP format. See the \"Notes\" below for more",
       "         details."],
     "A"=>
      ["[out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On exit, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ssptri"=>
  {"summary"=>
    ["SSPTRI computes the inverse of a real symmetric indefinite matrix",
     "A in packed storage using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by SSPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by SSPTRF,",
       "         stored as a packed triangular matrix.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix, stored as a packed triangular matrix. The j-th column",
       "         of inv(A) is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;",
       "         if UPLO = 'L',",
       "            AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSPTRF."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "sorglq"=>
  {"summary"=>
    ["SORGLQ generates an M-by-N real matrix Q with orthonormal rows,",
     "which is defined as the first M rows of a product of K elementary",
     "reflectors of order N",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by SGELQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the i-th row must contain the vector which defines",
       "         the elementary reflector H(i), for i = 1,2,...,k, as returned",
       "         by SGELQF in the first k rows of its array argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGELQF."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "sgerqf"=>
  {"summary"=>
    ["SGERQF computes an RQ factorization of a real M-by-N matrix A:",
     "A = R * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if m <= n, the upper triangle of the subarray",
       "         A(1:m,n-m+1:n) contains the M-by-M upper triangular matrix R;",
       "         if m >= n, the elements on and above the (m-n)-th subdiagonal",
       "         contain the M-by-N upper trapezoidal matrix R;",
       "         the remaining elements, with the array TAU, represent the",
       "         orthogonal matrix Q as a product of min(m,n) elementary",
       "         reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlapll"=>
  {"summary"=>
    ["Given two column vectors X and Y, let",
     "                     A = ( X Y ).",
     "The subroutine first computes the QR factorization of A = Q*R,",
     "and then computes the SVD of the 2-by-2 upper triangular matrix R.",
     "The smaller singular value of R is returned in SSMIN, which is used",
     "as the measurement of the linear dependency of the vectors X and Y."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The length of the vectors X and Y."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (1+(N-1)*INCX)",
       "         On entry, X contains the N-vector X.",
       "         On exit, X is overwritten."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension (1+(N-1)*INCY)",
       "         On entry, Y contains the N-vector Y.",
       "         On exit, Y is overwritten."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between successive elements of Y. INCY > 0."],
     "SSMIN"=>
      ["[out]",
       "         SSMIN is DOUBLE PRECISION",
       "         The smallest singular value of the N-by-2 matrix A = ( X Y )."]}},
 "zlar2v"=>
  {"summary"=>
    ["ZLAR2V applies a vector of complex plane rotations with real cosines",
     "from both sides to a sequence of 2-by-2 complex Hermitian matrices,",
     "defined by the elements of the vectors x, y and z. For i = 1,2,...,n",
     "   (       x(i)  z(i) ) :=",
     "   ( conjg(z(i)) y(i) )",
     "     (  c(i) conjg(s(i)) ) (       x(i)  z(i) ) ( c(i) -conjg(s(i)) )",
     "     ( -s(i)       c(i)  ) ( conjg(z(i)) y(i) ) ( s(i)        c(i)  )"],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be applied."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (1+(N-1)*INCX)",
       "         The vector x; the elements of x are assumed to be real."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension (1+(N-1)*INCX)",
       "         The vector y; the elements of y are assumed to be real."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (1+(N-1)*INCX)",
       "         The vector z."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X, Y and Z. INCX > 0."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is COMPLEX*16 array, dimension (1+(N-1)*INCC)",
       "         The sines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C and S. INCC > 0."]}},
 "dlarrd"=>
  {"summary"=>
    ["DLARRD computes the eigenvalues of a symmetric tridiagonal",
     "matrix T to suitable accuracy. This is an auxiliary code to be",
     "called from DSTEMR.",
     "The user may ask for all eigenvalues, all eigenvalues",
     "in the half-open interval (VL, VU], or the IL-th through IU-th",
     "eigenvalues.",
     "To avoid overflow, the matrix must be scaled so that its",
     "largest element is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest",
     "accuracy, it should not be much smaller than that.",
     "See W. Kahan \"Accurate Eigenvalues of a Symmetric Tridiagonal",
     "Matrix\", Report CS41, Computer Science Dept., Stanford",
     "University, July 21, 1966."],
   "param"=>
    {"RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': (\"All\")   all eigenvalues will be found.",
       "         = 'V': (\"Value\") all eigenvalues in the half-open interval",
       "                          (VL, VU] will be found.",
       "         = 'I': (\"Index\") the IL-th through IU-th eigenvalues (of the",
       "                          entire matrix) will be found."],
     "ORDER"=>
      ["[in]",
       "         ORDER is CHARACTER*1",
       "         = 'B': (\"By Block\") the eigenvalues will be grouped by",
       "                             split-off block (see IBLOCK, ISPLIT) and",
       "                             ordered from smallest to largest within",
       "                             the block.",
       "         = 'E': (\"Entire matrix\")",
       "                             the eigenvalues for the entire matrix",
       "                             will be ordered from smallest to",
       "                             largest."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix T.  N >= 0."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues.  Eigenvalues less than or equal",
       "         to VL, or greater than VU, will not be returned.  VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues.  Eigenvalues less than or equal",
       "         to VL, or greater than VU, will not be returned.  VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "GERS"=>
      ["[in]",
       "         GERS is DOUBLE PRECISION array, dimension (2*N)",
       "         The N Gerschgorin intervals (the i-th Gerschgorin interval",
       "         is (GERS(2*i-1), GERS(2*i))."],
     "RELTOL"=>
      ["[in]",
       "         RELTOL is DOUBLE PRECISION",
       "         The minimum relative width of an interval.  When an interval",
       "         is narrower than RELTOL times the larger (in",
       "         magnitude) endpoint, then it is considered to be",
       "         sufficiently small, i.e., converged.  Note: this should",
       "         always be at least radix*machine epsilon."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the tridiagonal matrix T."],
     "E2"=>
      ["[in]",
       "         E2 is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) squared off-diagonal elements of the tridiagonal matrix T."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "         The minimum pivot allowed in the Sturm sequence for T."],
     "NSPLIT"=>
      ["[in]",
       "         NSPLIT is INTEGER",
       "         The number of diagonal blocks in the matrix T.",
       "         1 <= NSPLIT <= N."],
     "ISPLIT"=>
      ["[in]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into submatrices.",
       "         The first submatrix consists of rows/columns 1 to ISPLIT(1),",
       "         the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),",
       "         etc., and the NSPLIT-th consists of rows/columns",
       "         ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.",
       "         (Only the first NSPLIT elements will actually be used, but",
       "         since the user cannot know a priori what value NSPLIT will",
       "         have, N words must be reserved for ISPLIT.)"],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The actual number of eigenvalues found. 0 <= M <= N.",
       "         (See also the description of INFO=2,3.)"],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         On exit, the first M elements of W will contain the",
       "         eigenvalue approximations. DLARRD computes an interval",
       "         I_j = (a_j, b_j] that includes eigenvalue j. The eigenvalue",
       "         approximation is given as the interval midpoint",
       "         W(j)= ( a_j + b_j)/2. The corresponding error is bounded by",
       "         WERR(j) = abs( a_j - b_j)/2"],
     "WERR"=>
      ["[out]",
       "         WERR is DOUBLE PRECISION array, dimension (N)",
       "         The error bound on the corresponding eigenvalue approximation",
       "         in W."],
     "WL"=>["[out]", "         WL is DOUBLE PRECISION"],
     "WU"=>
      ["[out]",
       "         WU is DOUBLE PRECISION",
       "         The interval (WL, WU] contains all the wanted eigenvalues.",
       "         If RANGE='V', then WL=VL and WU=VU.",
       "         If RANGE='A', then WL and WU are the global Gerschgorin bounds",
       "                       on the spectrum.",
       "         If RANGE='I', then WL and WU are computed by DLAEBZ from the",
       "                       index range specified."],
     "IBLOCK"=>
      ["[out]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         At each row/column j where E(j) is zero or small, the",
       "         matrix T is considered to split into a block diagonal",
       "         matrix.  On exit, if INFO = 0, IBLOCK(i) specifies to which",
       "         block (from 1 to the number of blocks) the eigenvalue W(i)",
       "         belongs.  (DLARRD may use the remaining N-M elements as",
       "         workspace.)"],
     "INDEXW"=>
      ["[out]",
       "         INDEXW is INTEGER array, dimension (N)",
       "         The indices of the eigenvalues within each block (submatrix);",
       "         for example, INDEXW(i)= j and IBLOCK(i)=k imply that the",
       "         i-th eigenvalue W(i) is the j-th eigenvalue in block k."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  some or all of the eigenvalues failed to converge or",
       "               were not computed:",
       "               =1 or 3: Bisection failed to converge for some",
       "                       eigenvalues; these eigenvalues are flagged by a",
       "                       negative block number.  The effect is that the",
       "                       eigenvalues may not be as accurate as the",
       "                       absolute and relative tolerances.  This is",
       "                       generally caused by unexpectedly inaccurate",
       "                       arithmetic.",
       "               =2 or 3: RANGE='I' only: Not all of the eigenvalues",
       "                       IL:IU were found.",
       "                       Effect: M < IU+1-IL",
       "                       Cause:  non-monotonic arithmetic, causing the",
       "                               Sturm sequence to be non-monotonic.",
       "                       Cure:   recalculate, using RANGE='A', and pick",
       "                               out eigenvalues IL:IU.  In some cases,",
       "                               increasing the PARAMETER \"FUDGE\" may",
       "                               make things work.",
       "               = 4:    RANGE='I', and the Gershgorin interval",
       "                       initially used was too small.  No eigenvalues",
       "                       were computed.",
       "                       Probable cause: your machine has sloppy",
       "                                       floating-point arithmetic.",
       "                       Cure: Increase the PARAMETER \"FUDGE\",",
       "                             recompile, and try again."]}},
 "zlangb"=>
  {"summary"=>
    ["ZLANGB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n band matrix  A,  with kl sub-diagonals and ku super-diagonals.",
     "   ZLANGB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANGB as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANGB is",
       "         set to zero."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of sub-diagonals of the matrix A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of super-diagonals of the matrix A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The band matrix A, stored in rows 1 to KL+KU+1.  The j-th",
       "         column of A is stored in the j-th column of the array AB as",
       "         follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "cla_gerfsx_extended"=>
  {"summary"=>
    ["CLA_GERFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by CGERFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERRS_N",
     "and ERRS_C for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERRS_N and ERRS_C."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "TRANS_TYPE"=>
      ["[in]",
       "         TRANS_TYPE is INTEGER",
       "    Specifies the transposition operation on A.",
       "    The value is defined by ILATRANS(T) where T is a CHARACTER and",
       "    T    = 'N':  No transpose",
       "         = 'T':  Transpose",
       "         = 'C':  Conjugate transpose"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by CGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by CGETRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by CGETRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is REAL array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by CLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERRS_N",
       "    and ERRS_C).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERRS_N"=>
      ["[in,out]",
       "         ERRS_N is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERRS_N(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERRS_N(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERRS_C"=>
      ["[in,out]",
       "         ERRS_C is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERRS_C is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERRS_C(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERRS_C(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]", "         AYB is REAL array, dimension (N)", "    Workspace."],
     "DY"=>
      ["[in]",
       "         DY is COMPLEX array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is COMPLEX array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERRS_N and ERRS_C may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is REAL",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is REAL",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to CGETRS had an illegal",
       "            value"]}},
 "dlamrg"=>
  {"summary"=>
    ["DLAMRG will create a permutation list which will merge the elements",
     "of A (which is composed of two independently sorted sets) into a",
     "single set which is sorted in ascending order."],
   "param"=>
    {"N1"=>["[in]", "         N1 is INTEGER"],
     "N2"=>
      ["[in]",
       "         N2 is INTEGER",
       "        These arguments contain the respective lengths of the two",
       "        sorted lists to be merged."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (N1+N2)",
       "        The first N1 elements of A contain a list of numbers which",
       "        are sorted in either ascending or descending order.  Likewise",
       "        for the final N2 elements."],
     "DTRD1"=>["[in]", "         DTRD1 is INTEGER"],
     "DTRD2"=>
      ["[in]",
       "         DTRD2 is INTEGER",
       "        These are the strides to be taken through the array A.",
       "        Allowable strides are 1 and -1.  They indicate whether a",
       "        subset of A is sorted in ascending (DTRDx = 1) or descending",
       "        (DTRDx = -1) order."],
     "INDEX"=>
      ["[out]",
       "         INDEX is INTEGER array, dimension (N1+N2)",
       "        On exit this array will contain a permutation such that",
       "        if B( I ) = A( INDEX( I ) ) for I=1,N1+N2, then B will be",
       "        sorted in ascending order."]}},
 "zhesvxx"=>
  {"summary"=>
    ["   ZHESVXX uses the diagonal pivoting factorization to compute the",
     "   solution to a complex*16 system of linear equations A * X = B, where",
     "   A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "   matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. ZHESVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   ZHESVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   ZHESVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what ZHESVXX would itself produce."],
   "param"=>nil},
 "sptrfs"=>
  {"summary"=>
    ["SPTRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric positive definite",
     "and tridiagonal, and provides error bounds and backward error",
     "estimates for the solution."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix A."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the tridiagonal matrix A."],
     "DF"=>
      ["[in]",
       "         DF is REAL array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         factorization computed by SPTTRF."],
     "EF"=>
      ["[in]",
       "         EF is REAL array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the unit bidiagonal factor",
       "         L from the factorization computed by SPTTRF."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by SPTTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j)."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgemlqt"=>
  {"summary"=>
    ["CGEMQRT overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q C            C Q",
     "TRANS = 'C':   Q**C C            C Q**C",
     "where Q is a complex orthogonal matrix defined as the product of K",
     "elementary reflectors:",
     "      Q = H(1) H(2) . . . H(K) = I - V C V**C",
     "generated using the compact WY representation as returned by CGELQT.",
     "Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**C from the Left;",
       "         = 'R': apply Q or Q**C from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**C."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size used for the storage of T.  K >= MB >= 1.",
       "         This must be the same value of MB used to generate T",
       "         in DGELQT."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension (LDV,K)",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGELQT in the first K rows of its array argument A."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by DGELQT, stored as a MB-by-M matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q C, Q**C C, C Q**C or C Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array. The dimension of",
       "         WORK is N*MB if SIDE = 'L', or  M*MB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgeqr"=>
  {"summary"=>["CGEQR computes a QR factorization of an M-by-N matrix A."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R",
       "         (R is upper triangular if M >= N);",
       "         the elements below the diagonal are used to store part of the ",
       "         data structure to represent Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (MAX(5,TSIZE))",
       "         On exit, if INFO = 0, T(1) returns optimal (or either minimal ",
       "         or optimal, if query is assumed) TSIZE. See TSIZE for details.",
       "         Remaining T contains part of the data structure used to represent Q.",
       "         If one wants to apply or construct Q, then one needs to keep T ",
       "         (in addition to A) and pass it to further subroutines."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         If TSIZE >= 5, the dimension of the array T.",
       "         If TSIZE = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If TSIZE = -1, the routine calculates optimal size of T for the ",
       "         optimum performance and returns this value in T(1).",
       "         If TSIZE = -2, the routine calculates minimal size of T and ",
       "         returns this value in T(1)."],
     "WORK"=>
      ["[out]",
       "         (workspace) COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgeqr2"=>
  {"summary"=>
    ["DGEQR2 computes a QR factorization of a real m by n matrix A:",
     "A = Q * R."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(m,n) by n upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n); the elements below the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaein"=>
  {"summary"=>
    ["DLAEIN uses inverse iteration to find a right or left eigenvector",
     "corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg",
     "matrix H."],
   "param"=>
    {"RIGHTV"=>
      ["[in]",
       "         RIGHTV is LOGICAL",
       "         = .TRUE. : compute right eigenvector;",
       "         = .FALSE.: compute left eigenvector."],
     "NOINIT"=>
      ["[in]",
       "         NOINIT is LOGICAL",
       "         = .TRUE. : no initial vector supplied in (VR,VI).",
       "         = .FALSE.: initial vector supplied in (VR,VI)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "H"=>
      ["[in]",
       "         H is DOUBLE PRECISION array, dimension (LDH,N)",
       "         The upper Hessenberg matrix H."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max(1,N)."],
     "WR"=>["[in]", "         WR is DOUBLE PRECISION"],
     "WI"=>
      ["[in]",
       "         WI is DOUBLE PRECISION",
       "         The real and imaginary parts of the eigenvalue of H whose",
       "         corresponding right or left eigenvector is to be computed."],
     "VR"=>
      ["[in,out]", "         VR is DOUBLE PRECISION array, dimension (N)"],
     "VI"=>
      ["[in,out]",
       "         VI is DOUBLE PRECISION array, dimension (N)",
       "         On entry, if NOINIT = .FALSE. and WI = 0.0, VR must contain",
       "         a real starting vector for inverse iteration using the real",
       "         eigenvalue WR; if NOINIT = .FALSE. and WI.ne.0.0, VR and VI",
       "         must contain the real and imaginary parts of a complex",
       "         starting vector for inverse iteration using the complex",
       "         eigenvalue (WR,WI); otherwise VR and VI need not be set.",
       "         On exit, if WI = 0.0 (real eigenvalue), VR contains the",
       "         computed real eigenvector; if WI.ne.0.0 (complex eigenvalue),",
       "         VR and VI contain the real and imaginary parts of the",
       "         computed complex eigenvector. The eigenvector is normalized",
       "         so that the component of largest magnitude has magnitude 1;",
       "         here the magnitude of a complex number (x,y) is taken to be",
       "         |x| + |y|.",
       "         VI is not referenced if WI = 0.0."],
     "B"=>["[out]", "         B is DOUBLE PRECISION array, dimension (LDB,N)"],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= N+1."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "EPS3"=>
      ["[in]",
       "         EPS3 is DOUBLE PRECISION",
       "         A small machine-dependent value which is used to perturb",
       "         close eigenvalues, and to replace zero pivots."],
     "SMLNUM"=>
      ["[in]",
       "         SMLNUM is DOUBLE PRECISION",
       "         A machine-dependent value close to the underflow threshold."],
     "BIGNUM"=>
      ["[in]",
       "         BIGNUM is DOUBLE PRECISION",
       "         A machine-dependent value close to the overflow threshold."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         = 1:  inverse iteration did not converge; VR is set to the",
       "               last iterate, and so is VI if WI.ne.0.0."]}},
 "ssyevd_2stage"=>
  {"summary"=>
    ["SSYEVD_2STAGE computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric matrix A using the 2stage technique for",
     "the reduction to tridiagonal. If eigenvectors are desired, it uses a",
     "divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array,",
       "                                        dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + 2*N+1",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + 2*N+1",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least",
       "                                               1 + 6*N + 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i and JOBZ = 'N', then the algorithm failed",
       "               to converge; i off-diagonal elements of an intermediate",
       "               tridiagonal form did not converge to zero;",
       "               if INFO = i and JOBZ = 'V', then the algorithm failed",
       "               to compute an eigenvalue while working on the submatrix",
       "               lying in rows and columns INFO/(N+1) through",
       "               mod(INFO,N+1)."]}},
 "csyr"=>
  {"summary"=>
    ["CSYR   performs the symmetric rank 1 operation",
     "   A := alpha*x*x**H + A,",
     "where alpha is a complex scalar, x is an n element vector and A is an",
     "n by n symmetric matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array A is to be referenced as",
       "          follows:",
       "             UPLO = 'U' or 'u'   Only the upper triangular part of A",
       "                                 is to be referenced.",
       "             UPLO = 'L' or 'l'   Only the lower triangular part of A",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the order of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCX ) ).",
       "          Before entry, the incremented array X must contain the N-",
       "          element vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension ( LDA, N )",
       "          Before entry, with  UPLO = 'U' or 'u', the leading n by n",
       "          upper triangular part of the array A must contain the upper",
       "          triangular part of the symmetric matrix and the strictly",
       "          lower triangular part of A is not referenced. On exit, the",
       "          upper triangular part of the array A is overwritten by the",
       "          upper triangular part of the updated matrix.",
       "          Before entry, with UPLO = 'L' or 'l', the leading n by n",
       "          lower triangular part of the array A must contain the lower",
       "          triangular part of the symmetric matrix and the strictly",
       "          upper triangular part of A is not referenced. On exit, the",
       "          lower triangular part of the array A is overwritten by the",
       "          lower triangular part of the updated matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, N ).",
       "          Unchanged on exit."]}},
 "zlassq"=>
  {"summary"=>
    ["ZLASSQ returns the values scl and ssq such that",
     "   ( scl**2 )*ssq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq,",
     "where x( i ) = abs( X( 1 + ( i - 1 )*INCX ) ). The value of sumsq is",
     "assumed to be at least unity and the value of ssq will then satisfy",
     "   1.0 .le. ssq .le. ( sumsq + 2*n ).",
     "scale is assumed to be non-negative and scl returns the value",
     "   scl = max( scale, abs( real( x( i ) ) ), abs( aimag( x( i ) ) ) ),",
     "          i",
     "scale and sumsq must be supplied in SCALE and SUMSQ respectively.",
     "SCALE and SUMSQ are overwritten by scl and ssq respectively.",
     "The routine makes only one pass through the vector X."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements to be used from the vector X."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension (N)",
       "         The vector x as described above.",
       "            x( i )  = X( 1 + ( i - 1 )*INCX ), 1 <= i <= n."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of the vector X.",
       "         INCX > 0."],
     "SCALE"=>
      ["[in,out]",
       "         SCALE is DOUBLE PRECISION",
       "         On entry, the value  scale  in the equation above.",
       "         On exit, SCALE is overwritten with the value  scl ."],
     "SUMSQ"=>
      ["[in,out]",
       "         SUMSQ is DOUBLE PRECISION",
       "         On entry, the value  sumsq  in the equation above.",
       "         On exit, SUMSQ is overwritten with the value  ssq ."]}},
 "csytri_3"=>
  {"summary"=>
    ["CSYTRI_3 computes the inverse of a complex symmetric indefinite",
     "matrix A using the factorization computed by CSYTRF_RK or CSYTRF_BK:",
     "    A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "CSYTRI_3 sets the leading dimension of the workspace  before calling",
     "CSYTRI_3X that actually computes the inverse.  This is the blocked",
     "version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by CSYTRF_RK and CSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the symmetric inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF_RK or CSYTRF_BK."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (N+NB+1)*(NB+3).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK. LWORK >= (N+NB+1)*(NB+3).",
       "         If LDWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the optimal",
       "         size of the WORK array, returns this value as the first",
       "         entry of the WORK array, and no error message related to",
       "         LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "claqhp"=>
  {"summary"=>
    ["CLAQHP equilibrates a Hermitian matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the equilibrated matrix:  diag(S) * A * diag(S), in",
       "         the same storage format as A."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is REAL",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "zppequ"=>
  {"summary"=>
    ["ZPPEQU computes row and column scalings intended to equilibrate a",
     "Hermitian positive definite matrix A in packed storage and reduce",
     "its condition number (with respect to the two-norm).  S contains the",
     "scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix",
     "B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal.",
     "This choice of S puts the condition number of B within a factor N of",
     "the smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the Hermitian matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is DOUBLE PRECISION",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "clatsqr"=>
  {"summary"=>
    ["SLATSQR computes a blocked Tall-Skinny QR factorization of",
     "an M-by-N matrix A, where M >= N:",
     "A = Q * R ."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. M >= N >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         MB > N."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal",
       "         of the array contain the N-by-N upper triangular matrix R;",
       "         the elements below the diagonal represent Q by the columns",
       "         of blocked V (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array,",
       "         dimension (LDT, N * Number_of_row_blocks)",
       "         where Number_of_row_blocks = CEIL((M-N)/(MB-N))",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.",
       "         See Further Details below."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>
      ["[out]", "        (workspace) COMPLEX array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         The dimension of the array WORK.  LWORK >= NB*N.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "spteqr"=>
  {"summary"=>
    ["SPTEQR computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric positive definite tridiagonal matrix by first factoring the",
     "matrix using SPTTRF, and then calling SBDSQR to compute the singular",
     "values of the bidiagonal factor.",
     "This routine computes the eigenvalues of the positive definite",
     "tridiagonal matrix to high relative accuracy.  This means that if the",
     "eigenvalues range over many orders of magnitude in size, then the",
     "small eigenvalues and corresponding eigenvectors will be computed",
     "more accurately than, for example, with the standard QR method.",
     "The eigenvectors of a full or band symmetric positive definite matrix",
     "can also be found if SSYTRD, SSPTRD, or SSBTRD has been used to",
     "reduce this matrix to tridiagonal form. (The reduction to tridiagonal",
     "form, however, may preclude the possibility of obtaining high",
     "relative accuracy in the small eigenvalues of the original matrix, if",
     "these eigenvalues range over many orders of magnitude.)"],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'V':  Compute eigenvectors of original symmetric",
       "                 matrix also.  Array Z contains the orthogonal",
       "                 matrix used to reduce the original matrix to",
       "                 tridiagonal form.",
       "         = 'I':  Compute eigenvectors of tridiagonal matrix also."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal",
       "         matrix.",
       "         On normal exit, D contains the eigenvalues, in descending",
       "         order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the orthogonal matrix used in the",
       "         reduction to tridiagonal form.",
       "         On exit, if COMPZ = 'V', the orthonormal eigenvectors of the",
       "         original symmetric matrix;",
       "         if COMPZ = 'I', the orthonormal eigenvectors of the",
       "         tridiagonal matrix.",
       "         If INFO > 0 on exit, Z contains the eigenvectors associated",
       "         with only the stored eigenvalues.",
       "         If  COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         COMPZ = 'V' or 'I', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, and i is:",
       "               <= N  the Cholesky factorization of the matrix could",
       "                     not be performed because the i-th principal minor",
       "                     was not positive definite.",
       "               > N   the SVD algorithm failed to converge;",
       "                     if INFO = N+i, i off-diagonal elements of the",
       "                     bidiagonal factor did not converge to zero."]}},
 "zhptri"=>
  {"summary"=>
    ["ZHPTRI computes the inverse of a complex Hermitian indefinite matrix",
     "A in packed storage using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by ZHPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by ZHPTRF,",
       "         stored as a packed triangular matrix.",
       "         On exit, if INFO = 0, the (Hermitian) inverse of the original",
       "         matrix, stored as a packed triangular matrix. The j-th column",
       "         of inv(A) is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;",
       "         if UPLO = 'L',",
       "            AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHPTRF."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "zgesvx"=>
  {"summary"=>
    ["ZGESVX uses the LU factorization to compute the solution to a complex",
     "system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N matrix and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "srscl"=>
  {"summary"=>
    ["SRSCL multiplies an n-element real vector x by the real scalar 1/a.",
     "This is done without overflow or underflow as long as",
     "the final result x/a does not overflow or underflow."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of components of the vector x."],
     "SA"=>
      ["[in]",
       "         SA is REAL",
       "         The scalar a which is used to divide each component of x.",
       "         SA must be >= 0, or the subroutine will divide by zero."],
     "SX"=>
      ["[in,out]",
       "         SX is REAL array, dimension",
       "                        (1+(N-1)*abs(INCX))",
       "         The n-element vector x."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of the vector SX.",
       "         > 0:  SX(1) = X(1) and SX(1+(i-1)*INCX) = x(i),     1< i<= n"]}},
 "zggsvp3"=>
  {"summary"=>
    ["ZGGSVP3 computes unitary matrices U, V and Q such that",
     "                   N-K-L  K    L",
     " U**H*A*Q =     K ( 0    A12  A13 )  if M-K-L >= 0;",
     "                L ( 0     0   A23 )",
     "            M-K-L ( 0     0    0  )",
     "                 N-K-L  K    L",
     "        =     K ( 0    A12  A13 )  if M-K-L < 0;",
     "            M-K ( 0     0   A23 )",
     "                 N-K-L  K    L",
     " V**H*B*Q =   L ( 0     0   B13 )",
     "            P-L ( 0     0    0  )",
     "where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular",
     "upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,",
     "otherwise A23 is (M-K)-by-L upper trapezoidal.  K+L = the effective",
     "numerical rank of the (M+P)-by-N matrix (A**H,B**H)**H.",
     "This decomposition is the preprocessing step for computing the",
     "Generalized Singular Value Decomposition (GSVD), see subroutine",
     "ZGGSVD3."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  Unitary matrix U is computed;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  Unitary matrix V is computed;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Unitary matrix Q is computed;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A contains the triangular (or trapezoidal) matrix",
       "         described in the Purpose section."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, B contains the triangular matrix described in",
       "         the Purpose section."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TOLA"=>["[in]", "         TOLA is DOUBLE PRECISION"],
     "TOLB"=>
      ["[in]",
       "         TOLB is DOUBLE PRECISION",
       "         TOLA and TOLB are the thresholds to determine the effective",
       "         numerical rank of matrix B and a subblock of A. Generally,",
       "         they are set to",
       "            TOLA = MAX(M,N)*norm(A)*MAZHEPS,",
       "            TOLB = MAX(P,N)*norm(B)*MAZHEPS.",
       "         The size of TOLA and TOLB may affect the size of backward",
       "         errors of the decomposition."],
     "K"=>["[out]", "         K is INTEGER"],
     "L"=>
      ["[out]",
       "         L is INTEGER",
       "         On exit, K and L specify the dimension of the subblocks",
       "         described in Purpose section.",
       "         K + L = effective numerical rank of (A**H,B**H)**H."],
     "U"=>
      ["[out]",
       "         U is COMPLEX*16 array, dimension (LDU,M)",
       "         If JOBU = 'U', U contains the unitary matrix U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[out]",
       "         V is COMPLEX*16 array, dimension (LDV,P)",
       "         If JOBV = 'V', V contains the unitary matrix V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,N)",
       "         If JOBQ = 'Q', Q contains the unitary matrix Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "TAU"=>["[out]", "         TAU is COMPLEX*16 array, dimension (N)"],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "clauu2"=>
  {"summary"=>
    ["CLAUU2 computes the product U * U**H or L**H * L, where the triangular",
     "factor U or L is stored in the upper or lower triangular part of",
     "the array A.",
     "If UPLO = 'U' or 'u' then the upper triangle of the result is stored,",
     "overwriting the factor U in A.",
     "If UPLO = 'L' or 'l' then the lower triangle of the result is stored,",
     "overwriting the factor L in A.",
     "This is the unblocked form of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the triangular factor stored in the array A",
       "         is upper or lower triangular:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the triangular factor U or L.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L.",
       "         On exit, if UPLO = 'U', the upper triangle of A is",
       "         overwritten with the upper triangle of the product U * U**H;",
       "         if UPLO = 'L', the lower triangle of A is overwritten with",
       "         the lower triangle of the product L**H * L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "csytrf_aa"=>
  {"summary"=>
    ["CSYTRF_AA computes the factorization of a complex symmetric matrix A",
     "using the Aasen's algorithm.  The form of the factorization is",
     "   A = U*T*U**T  or  A = L*T*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is a complex symmetric tridiagonal matrix.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the tridiagonal matrix is stored in the diagonals",
       "         and the subdiagonals of A just below (or above) the diagonals,",
       "         and L is stored below (or above) the subdiaonals, when UPLO",
       "         is 'L' (or 'U')."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK. LWORK >= MAX(1,2*N). For optimum performance",
       "         LWORK >= N*(1+NB), where NB is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "zgetrf2"=>
  {"summary"=>
    ["ZGETRF2 computes an LU factorization of a general M-by-N matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the recursive version of the algorithm. It divides",
     "the matrix into four submatrices:",
     "       [  A11 | A12  ]  where A11 is n1 by n1 and A22 is n2 by n2",
     "   A = [ -----|----- ]  with n1 = min(m,n)/2",
     "       [  A21 | A22  ]       n2 = n-n1",
     "                                      [ A11 ]",
     "The subroutine calls itself to factor [ --- ],",
     "                                      [ A12 ]",
     "                [ A12 ]",
     "do the swaps on [ --- ], solve A12, update A22,",
     "                [ A22 ]",
     "then calls itself to factor A22 and do the swaps on A21."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "ssytri_3"=>
  {"summary"=>
    ["SSYTRI_3 computes the inverse of a real symmetric indefinite",
     "matrix A using the factorization computed by SSYTRF_RK or SSYTRF_BK:",
     "    A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "SSYTRI_3 sets the leading dimension of the workspace  before calling",
     "SSYTRI_3X that actually computes the inverse.  This is the blocked",
     "version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by SSYTRF_RK and SSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the symmetric inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF_RK or SSYTRF_BK."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (N+NB+1)*(NB+3).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK. LWORK >= (N+NB+1)*(NB+3).",
       "         If LDWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the optimal",
       "         size of the WORK array, returns this value as the first",
       "         entry of the WORK array, and no error message related to",
       "         LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "dlas2"=>
  {"summary"=>
    ["DLAS2  computes the singular values of the 2-by-2 matrix",
     "   [  F   G  ]",
     "   [  0   H  ].",
     "On return, SSMIN is the smaller singular value and SSMAX is the",
     "larger singular value."],
   "param"=>
    {"F"=>
      ["[in]",
       "         F is DOUBLE PRECISION",
       "         The (1,1) element of the 2-by-2 matrix."],
     "G"=>
      ["[in]",
       "         G is DOUBLE PRECISION",
       "         The (1,2) element of the 2-by-2 matrix."],
     "H"=>
      ["[in]",
       "         H is DOUBLE PRECISION",
       "         The (2,2) element of the 2-by-2 matrix."],
     "SSMIN"=>
      ["[out]",
       "         SSMIN is DOUBLE PRECISION",
       "         The smaller singular value."],
     "SSMAX"=>
      ["[out]",
       "         SSMAX is DOUBLE PRECISION",
       "         The larger singular value."]}},
 "dorbdb3"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M. M-P <= min(P,Q,M-Q)."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is DOUBLE PRECISION array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is DOUBLE PRECISION array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is DOUBLE PRECISION array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is DOUBLE PRECISION array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is DOUBLE PRECISION array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ssyevx_2stage"=>
  {"summary"=>
    ["SSYEVX_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  Eigenvalues and eigenvectors can be",
     "selected by specifying either a range of values or a range of indices",
     "for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, 8*N, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + 3*N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + 3*N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "zlarrv"=>
  {"summary"=>
    ["ZLARRV computes the eigenvectors of the tridiagonal matrix",
     "T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T.",
     "The input eigenvalues should have been computed by DLARRE."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         Lower bound of the interval that contains the desired",
       "         eigenvalues. VL < VU. Needed to compute gaps on the left or right",
       "         end of the extremal eigenvalues in the desired RANGE."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         Upper bound of the interval that contains the desired",
       "         eigenvalues. VL < VU. Needed to compute gaps on the left or right",
       "         end of the extremal eigenvalues in the desired RANGE."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the N diagonal elements of the diagonal matrix D.",
       "         On exit, D may be overwritten."],
     "L"=>
      ["[in,out]",
       "         L is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the unit",
       "         bidiagonal matrix L are in elements 1 to N-1 of L",
       "         (if the matrix is not split.) At the end of each block",
       "         is stored the corresponding shift as given by DLARRE.",
       "         On exit, L is overwritten."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "         The minimum pivot allowed in the Sturm sequence."],
     "ISPLIT"=>
      ["[in]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into blocks.",
       "         The first block consists of rows/columns 1 to",
       "         ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1",
       "         through ISPLIT( 2 ), etc."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of input eigenvalues.  0 <= M <= N."],
     "DOL"=>["[in]", "         DOL is INTEGER"],
     "DOU"=>
      ["[in]",
       "         DOU is INTEGER",
       "         If the user wants to compute only selected eigenvectors from all",
       "         the eigenvalues supplied, he can specify an index range DOL:DOU.",
       "         Or else the setting DOL=1, DOU=M should be applied.",
       "         Note that DOL and DOU refer to the order in which the eigenvalues",
       "         are stored in W.",
       "         If the user wants to compute only selected eigenpairs, then",
       "         the columns DOL-1 to DOU+1 of the eigenvector space Z contain the",
       "         computed eigenvectors. All other columns of Z are set to zero."],
     "MINRGP"=>["[in]", "         MINRGP is DOUBLE PRECISION"],
     "RTOL1"=>["[in]", "         RTOL1 is DOUBLE PRECISION"],
     "RTOL2"=>
      ["[in]",
       "         RTOL2 is DOUBLE PRECISION",
       "          Parameters for bisection.",
       "          An interval [LEFT,RIGHT] has converged if",
       "          RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )"],
     "W"=>
      ["[in,out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements of W contain the APPROXIMATE eigenvalues for",
       "         which eigenvectors are to be computed.  The eigenvalues",
       "         should be grouped by split-off block and ordered from",
       "         smallest to largest within the block ( The output array",
       "         W from DLARRE is expected here ). Furthermore, they are with",
       "         respect to the shift of the corresponding root representation",
       "         for their block. On exit, W holds the eigenvalues of the",
       "         UNshifted matrix."],
     "WERR"=>
      ["[in,out]",
       "         WERR is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the semiwidth of the uncertainty",
       "         interval of the corresponding eigenvalue in W"],
     "WGAP"=>
      ["[in,out]",
       "         WGAP is DOUBLE PRECISION array, dimension (N)",
       "         The separation from the right neighbor eigenvalue in W."],
     "IBLOCK"=>
      ["[in]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         The indices of the blocks (submatrices) associated with the",
       "         corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue",
       "         W(i) belongs to the first block from the top, =2 if W(i)",
       "         belongs to the second block, etc."],
     "INDEXW"=>
      ["[in]",
       "         INDEXW is INTEGER array, dimension (N)",
       "         The indices of the eigenvalues within each block (submatrix);",
       "         for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the",
       "         i-th eigenvalue W(i) is the 10-th eigenvalue in the second block."],
     "GERS"=>
      ["[in]",
       "         GERS is DOUBLE PRECISION array, dimension (2*N)",
       "         The N Gerschgorin intervals (the i-th Gerschgorin interval",
       "         is (GERS(2*i-1), GERS(2*i)). The Gerschgorin intervals should",
       "         be computed from the original UNshifted matrix."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, max(1,M) )",
       "         If INFO = 0, the first M columns of Z contain the",
       "         orthonormal eigenvectors of the matrix T",
       "         corresponding to the input eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The I-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*I-1 ) through",
       "         ISUPPZ( 2*I )."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (12*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (7*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         > 0:  A problem occurred in ZLARRV.",
       "         < 0:  One of the called subroutines signaled an internal problem.",
       "               Needs inspection of the corresponding parameter IINFO",
       "               for further information.",
       "         =-1:  Problem in DLARRB when refining a child's eigenvalues.",
       "         =-2:  Problem in DLARRF when computing the RRR of a child.",
       "               When a child is inside a tight cluster, it can be difficult",
       "               to find an RRR. A partial remedy from the user's point of",
       "               view is to make the parameter MINRGP smaller and recompile.",
       "               However, as the orthogonality of the computed vectors is",
       "               proportional to 1/MINRGP, the user should be aware that",
       "               he might be trading in precision when he decreases MINRGP.",
       "         =-3:  Problem in DLARRB when refining a single eigenvalue",
       "               after the Rayleigh correction was rejected.",
       "         = 5:  The Rayleigh Quotient Iteration failed to converge to",
       "               full accuracy in MAXITR steps."]}},
 "dspgst"=>
  {"summary"=>
    ["DSPGST reduces a real symmetric-definite generalized eigenproblem",
     "to standard form, using packed storage.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L.",
     "B must have been previously factorized as U**T*U or L*L**T by DPPTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T);",
       "         = 2 or 3: compute U*A*U**T or L**T*A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored and B is factored as",
       "                 U**T*U;",
       "         = 'L':  Lower triangle of A is stored and B is factored as",
       "                 L*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "BP"=>
      ["[in]",
       "         BP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         stored in the same format as A, as returned by DPPTRF."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgetf2"=>
  {"summary"=>
    ["CGETF2 computes an LU factorization of a general m-by-n matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the right-looking Level 2 BLAS version of the algorithm."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the m by n matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, U(k,k) is exactly zero. The factorization",
       "              has been completed, but the factor U is exactly",
       "              singular, and division by zero will occur if it is used",
       "              to solve a system of equations."]}},
 "zhetf2_rook"=>
  {"summary"=>
    ["ZHETF2_ROOK computes the factorization of a complex Hermitian matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method:",
     "   A = U*D*U**H  or  A = L*D*L**H",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**H is the conjugate transpose of U, and D is",
     "Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "zhbevd_2stage"=>
  {"summary"=>
    ["ZHBEVD_2STAGE computes all the eigenvalues and, optionally, eigenvectors of",
     "a complex Hermitian band matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  If eigenvectors are desired, it",
     "uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX*16 array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = (2KD+1)*N + KD*NTHREADS",
       "                                  where KD is the size of the band.",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array,",
       "                                        dimension (LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK.",
       "         If N <= 1,               LRWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LRWORK must be at least N.",
       "         If JOBZ = 'V' and N > 1, LRWORK must be at least",
       "                       1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of array IWORK.",
       "         If JOBZ = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ = 'V' and N > 1, LIWORK must be at least 3 + 5*N .",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dlacn2"=>
  {"summary"=>
    ["DLACN2 estimates the 1-norm of a square, real matrix A.",
     "Reverse communication is used for evaluating matrix-vector products."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The order of the matrix.  N >= 1."],
     "V"=>
      ["[out]",
       "         V is DOUBLE PRECISION array, dimension (N)",
       "        On the final return, V = A*W,  where  EST = norm(V)/norm(W)",
       "        (W is not returned)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (N)",
       "        On an intermediate return, X should be overwritten by",
       "              A * X,   if KASE=1,",
       "              A**T * X,  if KASE=2,",
       "        and DLACN2 must be re-called with all the other parameters",
       "        unchanged."],
     "ISGN"=>["[out]", "         ISGN is INTEGER array, dimension (N)"],
     "EST"=>
      ["[in,out]",
       "         EST is DOUBLE PRECISION",
       "        On entry with KASE = 1 or 2 and ISAVE(1) = 3, EST should be",
       "        unchanged from the previous call to DLACN2.",
       "        On exit, EST is an estimate (a lower bound) for norm(A)."],
     "KASE"=>
      ["[in,out]",
       "         KASE is INTEGER",
       "        On the initial call to DLACN2, KASE should be 0.",
       "        On an intermediate return, KASE will be 1 or 2, indicating",
       "        whether X should be overwritten by A * X  or A**T * X.",
       "        On the final return from DLACN2, KASE will again be 0."],
     "ISAVE"=>
      ["[in,out]",
       "         ISAVE is INTEGER array, dimension (3)",
       "        ISAVE is used to save variables between calls to DLACN2"]}},
 "dlarfg"=>
  {"summary"=>
    ["DLARFG generates a real elementary reflector H of order n, such",
     "that",
     "      H * ( alpha ) = ( beta ),   H**T * H = I.",
     "          (   x   )   (   0  )",
     "where alpha and beta are scalars, and x is an (n-1)-element real",
     "vector. H is represented in the form",
     "      H = I - tau * ( 1 ) * ( 1 v**T ) ,",
     "                    ( v )",
     "where tau is a real scalar and v is a real (n-1)-element",
     "vector.",
     "If the elements of x are all zero, then tau = 0 and H is taken to be",
     "the unit matrix.",
     "Otherwise  1 <= tau <= 2."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the elementary reflector."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is DOUBLE PRECISION",
       "         On entry, the value alpha.",
       "         On exit, it is overwritten with the value beta."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension",
       "                        (1+(N-2)*abs(INCX))",
       "         On entry, the vector x.",
       "         On exit, it is overwritten with the vector v."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION",
       "         The value tau."]}},
 "dlaset"=>
  {"summary"=>
    ["DLASET initializes an m-by-n matrix A to BETA on the diagonal and",
     "ALPHA on the offdiagonals."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the part of the matrix A to be set.",
       "         = 'U':      Upper triangular part is set; the strictly lower",
       "                     triangular part of A is not changed.",
       "         = 'L':      Lower triangular part is set; the strictly upper",
       "                     triangular part of A is not changed.",
       "         Otherwise:  All of the matrix A is set."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "         The constant to which the offdiagonal elements are to be set."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION",
       "         The constant to which the diagonal elements are to be set."],
     "A"=>
      ["[out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On exit, the leading m-by-n submatrix of A is set as follows:",
       "         if UPLO = 'U', A(i,j) = ALPHA, 1<=i<=j-1, 1<=j<=n,",
       "         if UPLO = 'L', A(i,j) = ALPHA, j+1<=i<=m, 1<=j<=n,",
       "         otherwise,     A(i,j) = ALPHA, 1<=i<=m, 1<=j<=n, i.ne.j,",
       "         and, for all UPLO, A(i,i) = BETA, 1<=i<=min(m,n)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."]}},
 "dgeqlf"=>
  {"summary"=>
    ["DGEQLF computes a QL factorization of a real M-by-N matrix A:",
     "A = Q * L."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if m >= n, the lower triangle of the subarray",
       "         A(m-n+1:m,1:n) contains the N-by-N lower triangular matrix L;",
       "         if m <= n, the elements on and below the (n-m)-th",
       "         superdiagonal contain the M-by-N lower trapezoidal matrix L;",
       "         the remaining elements, with the array TAU, represent the",
       "         orthogonal matrix Q as a product of elementary reflectors",
       "         (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "scsum1"=>
  {"summary"=>
    ["SCSUM1 takes the sum of the absolute values of a complex",
     "vector and returns a single precision result.",
     "Based on SCASUM from the Level 1 BLAS.",
     "The change is to use the 'genuine' absolute value."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements in the vector CX."],
     "CX"=>
      ["[in]",
       "         CX is COMPLEX array, dimension (N)",
       "         The vector whose elements will be summed."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The spacing between successive values of CX.  INCX > 0."]}},
 "csytrs_rook"=>
  {"summary"=>
    ["CSYTRS_ROOK solves a system of linear equations A*X = B with",
     "a complex symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by CSYTRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF_ROOK."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlarfx"=>
  {"summary"=>
    ["DLARFX applies a real elementary reflector H to a real m by n",
     "matrix C, from either the left or the right. H is represented in the",
     "form",
     "      H = I - tau * v * v**T",
     "where tau is a real scalar and v is a real vector.",
     "If tau = 0, then H is taken to be the unit matrix",
     "This version uses inline code if H has order < 11."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension (M) if SIDE = 'L'",
       "                                    or (N) if SIDE = 'R'",
       "         The vector v in the representation of H."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDA >= (1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension",
       "                     (N) if SIDE = 'L'",
       "                     or (M) if SIDE = 'R'",
       "         WORK is not referenced if H has order < 11."]}},
 "dstev"=>
  {"summary"=>
    ["DSTEV computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric tridiagonal matrix A."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A, stored in elements 1 to N-1 of E.",
       "         On exit, the contents of E are destroyed."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with D(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (max(1,2*N-2))",
       "         If JOBZ = 'N', WORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of E did not converge to zero."]}},
 "clasyf_rook"=>
  {"summary"=>
    ["CLASYF_ROOK computes a partial factorization of a complex symmetric",
     "matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal",
     "pivoting method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**T L21**T )  if UPLO = 'L'",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "CLASYF_ROOK is an auxiliary routine called by CSYTRF_ROOK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "W"=>["[out]", "         W is COMPLEX array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "sgees"=>
  {"summary"=>
    ["SGEES computes for an N-by-N real nonsymmetric matrix A, the",
     "eigenvalues, the real Schur form T, and, optionally, the matrix of",
     "Schur vectors Z.  This gives the Schur factorization A = Z*T*(Z**T).",
     "Optionally, it also orders the eigenvalues on the diagonal of the",
     "real Schur form so that selected eigenvalues are at the top left.",
     "The leading columns of Z then form an orthonormal basis for the",
     "invariant subspace corresponding to the selected eigenvalues.",
     "A matrix is in real Schur form if it is upper quasi-triangular with",
     "1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in the",
     "form",
     "        [  a  b  ]",
     "        [  c  a  ]",
     "where b*c < 0. The eigenvalues of such a block are a +- sqrt(bc)."],
   "param"=>
    {"JOBVS"=>
      ["[in]",
       "         JOBVS is CHARACTER*1",
       "         = 'N': Schur vectors are not computed;",
       "         = 'V': Schur vectors are computed."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the Schur form.",
       "         = 'N': Eigenvalues are not ordered;",
       "         = 'S': Eigenvalues are ordered (see SELECT)."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL FUNCTION of two REAL arguments",
       "         SELECT must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'S', SELECT is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         If SORT = 'N', SELECT is not referenced.",
       "         An eigenvalue WR(j)+sqrt(-1)*WI(j) is selected if",
       "         SELECT(WR(j),WI(j)) is true; i.e., if either one of a complex",
       "         conjugate pair of eigenvalues is selected, then both complex",
       "         eigenvalues are selected.",
       "         Note that a selected complex eigenvalue may no longer",
       "         satisfy SELECT(WR(j),WI(j)) = .TRUE. after ordering, since",
       "         ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned); in this",
       "         case INFO is set to N+2 (see INFO below)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten by its real Schur form T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "                        for which SELECT is true. (Complex conjugate",
       "                        pairs for which SELECT is true for either",
       "                        eigenvalue count as 2.)"],
     "WR"=>["[out]", "         WR is REAL array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is REAL array, dimension (N)",
       "         WR and WI contain the real and imaginary parts,",
       "         respectively, of the computed eigenvalues in the same order",
       "         that they appear on the diagonal of the output Schur form T.",
       "         Complex conjugate pairs of eigenvalues will appear",
       "         consecutively with the eigenvalue having the positive",
       "         imaginary part first."],
     "VS"=>
      ["[out]",
       "         VS is REAL array, dimension (LDVS,N)",
       "         If JOBVS = 'V', VS contains the orthogonal matrix Z of Schur",
       "         vectors.",
       "         If JOBVS = 'N', VS is not referenced."],
     "LDVS"=>
      ["[in]",
       "         LDVS is INTEGER",
       "         The leading dimension of the array VS.  LDVS >= 1; if",
       "         JOBVS = 'V', LDVS >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,3*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value.",
       "         > 0: if INFO = i, and i is",
       "            <= N: the QR algorithm failed to compute all the",
       "                  eigenvalues; elements 1:ILO-1 and i+1:N of WR and WI",
       "                  contain those eigenvalues which have converged; if",
       "                  JOBVS = 'V', VS contains the matrix which reduces A",
       "                  to its partially converged Schur form.",
       "            = N+1: the eigenvalues could not be reordered because some",
       "                  eigenvalues were too close to separate (the problem",
       "                  is very ill-conditioned);",
       "            = N+2: after reordering, roundoff changed values of some",
       "                  complex eigenvalues so that leading eigenvalues in",
       "                  the Schur form no longer satisfy SELECT=.TRUE.  This",
       "                  could also be caused by underflow due to scaling."]}},
 "claqr3"=>
  {"summary"=>
    ["   Aggressive early deflation:",
     "   CLAQR3 accepts as input an upper Hessenberg matrix",
     "   H and performs an unitary similarity transformation",
     "   designed to detect and deflate fully converged eigenvalues from",
     "   a trailing principal submatrix.  On output H has been over-",
     "   written by a new Hessenberg matrix that is a perturbation of",
     "   an unitary similarity transformation of H.  It is to be",
     "   hoped that the final version of H has many zero subdiagonal",
     "   entries."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         If .TRUE., then the Hessenberg matrix H is fully updated",
       "         so that the triangular Schur factor may be",
       "         computed (in cooperation with the calling subroutine).",
       "         If .FALSE., then only enough of H is updated to preserve",
       "         the eigenvalues."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         If .TRUE., then the unitary matrix Z is updated so",
       "         so that the unitary Schur factor may be computed",
       "         (in cooperation with the calling subroutine).",
       "         If .FALSE., then Z is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H and (if WANTZ is .TRUE.) the",
       "         order of the unitary matrix Z."],
     "KTOP"=>
      ["[in]",
       "         KTOP is INTEGER",
       "         It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.",
       "         KBOT and KTOP together determine an isolated block",
       "         along the diagonal of the Hessenberg matrix."],
     "KBOT"=>
      ["[in]",
       "         KBOT is INTEGER",
       "         It is assumed without a check that either",
       "         KBOT = N or H(KBOT+1,KBOT)=0.  KBOT and KTOP together",
       "         determine an isolated block along the diagonal of the",
       "         Hessenberg matrix."],
     "NW"=>
      ["[in]",
       "         NW is INTEGER",
       "         Deflation window size.  1 .LE. NW .LE. (KBOT-KTOP+1)."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX array, dimension (LDH,N)",
       "         On input the initial N-by-N section of H stores the",
       "         Hessenberg matrix undergoing aggressive early deflation.",
       "         On output H has been transformed by a unitary",
       "         similarity transformation, perturbed, and the returned",
       "         to Hessenberg form that (it is to be hoped) has some",
       "         zero subdiagonal entries."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "         Leading dimension of H just as declared in the calling",
       "         subroutine.  N .LE. LDH"],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ,N)",
       "         IF WANTZ is .TRUE., then on output, the unitary",
       "         similarity transformation mentioned above has been",
       "         accumulated into Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "         If WANTZ is .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer",
       "         The leading dimension of Z just as declared in the",
       "         calling subroutine.  1 .LE. LDZ."],
     "NS"=>
      ["[out]",
       "         NS is integer",
       "         The number of unconverged (ie approximate) eigenvalues",
       "         returned in SR and SI that may be used as shifts by the",
       "         calling subroutine."],
     "ND"=>
      ["[out]",
       "         ND is integer",
       "         The number of converged eigenvalues uncovered by this",
       "         subroutine."],
     "SH"=>
      ["[out]",
       "         SH is COMPLEX array, dimension KBOT",
       "         On output, approximate eigenvalues that may",
       "         be used for shifts are stored in SH(KBOT-ND-NS+1)",
       "         through SR(KBOT-ND).  Converged eigenvalues are",
       "         stored in SH(KBOT-ND+1) through SH(KBOT)."],
     "V"=>
      ["[out]",
       "         V is COMPLEX array, dimension (LDV,NW)",
       "         An NW-by-NW work array."],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "         The leading dimension of V just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "         The number of columns of T.  NH.GE.NW."],
     "T"=>["[out]", "         T is COMPLEX array, dimension (LDT,NW)"],
     "LDT"=>
      ["[in]",
       "         LDT is integer",
       "         The leading dimension of T just as declared in the",
       "         calling subroutine.  NW .LE. LDT"],
     "NV"=>
      ["[in]",
       "         NV is integer",
       "         The number of rows of work array WV available for",
       "         workspace.  NV.GE.NW."],
     "WV"=>["[out]", "         WV is COMPLEX array, dimension (LDWV,NW)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer",
       "         The leading dimension of W just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension LWORK.",
       "         On exit, WORK(1) is set to an estimate of the optimal value",
       "         of LWORK for the given values of N, NW, KTOP and KBOT."],
     "LWORK"=>
      ["[in]",
       "         LWORK is integer",
       "         The dimension of the work array WORK.  LWORK = 2*NW",
       "         suffices, but greater efficiency may result from larger",
       "         values of LWORK.",
       "         If LWORK = -1, then a workspace query is assumed; CLAQR3",
       "         only estimates the optimal workspace size for the given",
       "         values of N, NW, KTOP and KBOT.  The estimate is returned",
       "         in WORK(1).  No error message related to LWORK is issued",
       "         by XERBLA.  Neither H nor Z are accessed."]}},
 "sporfsx"=>
  {"summary"=>
    ["   SPORFSX improves the computed solution to a system of linear",
     "   equations when the coefficient matrix is symmetric positive",
     "   definite, and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED and S",
     "   below. In this case, the solution and error bounds returned are",
     "   for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'Y':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(S) * A * diag(S).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "    upper triangular part of A contains the upper triangular part",
       "    of the matrix A, and the strictly lower triangular part of A",
       "    is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "    triangular part of A contains the lower triangular part of",
       "    the matrix A, and the strictly upper triangular part of A is",
       "    not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by SPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "S"=>
      ["[in,out]",
       "         S is REAL array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'Y', A is multiplied on",
       "    the left and right by diag(S).  S is an input argument if FACT =",
       "    'F'; otherwise, S is an output argument.  If FACT = 'F' and EQUED",
       "    = 'Y', each element of S must be positive.  If S is output, each",
       "    element of S is a power of the radix. If S is input, each element",
       "    of S should be a power of the radix to ensure a reliable solution",
       "    and error estimates. Scaling by powers of the radix does not cause",
       "    rounding errors unless the result underflows or overflows.",
       "    Rounding errors during scaling lead to refining with a matrix that",
       "    is not equivalent to the input matrix, producing error estimates",
       "    that may not be reliable."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by SGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is REAL array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "slatrd"=>
  {"summary"=>
    ["SLATRD reduces NB rows and columns of a real symmetric matrix A to",
     "symmetric tridiagonal form by an orthogonal similarity",
     "transformation Q**T * A * Q, and returns the matrices V and W which are",
     "needed to apply the transformation to the unreduced part of A.",
     "If UPLO = 'U', SLATRD reduces the last NB rows and columns of a",
     "matrix, of which the upper triangle is supplied;",
     "if UPLO = 'L', SLATRD reduces the first NB rows and columns of a",
     "matrix, of which the lower triangle is supplied.",
     "This is an auxiliary routine called by SSYTRD."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U': Upper triangular",
       "         = 'L': Lower triangular"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of rows and columns to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit:",
       "         if UPLO = 'U', the last NB columns have been reduced to",
       "           tridiagonal form, with the diagonal elements overwriting",
       "           the diagonal elements of A; the elements above the diagonal",
       "           with the array TAU, represent the orthogonal matrix Q as a",
       "           product of elementary reflectors;",
       "         if UPLO = 'L', the first NB columns have been reduced to",
       "           tridiagonal form, with the diagonal elements overwriting",
       "           the diagonal elements of A; the elements below the diagonal",
       "           with the array TAU, represent the  orthogonal matrix Q as a",
       "           product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= (1,N)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         If UPLO = 'U', E(n-nb:n-1) contains the superdiagonal",
       "         elements of the last NB columns of the reduced matrix;",
       "         if UPLO = 'L', E(1:nb) contains the subdiagonal elements of",
       "         the first NB columns of the reduced matrix."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors, stored in",
       "         TAU(n-nb:n-1) if UPLO = 'U', and in TAU(1:nb) if UPLO = 'L'.",
       "         See Further Details."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (LDW,NB)",
       "         The n-by-nb matrix W required to update the unreduced part",
       "         of A."],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W. LDW >= max(1,N)."]}},
 "dgemqrt"=>
  {"summary"=>
    ["DGEMQRT overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q C            C Q",
     "TRANS = 'T':   Q**T C            C Q**T",
     "where Q is a real orthogonal matrix defined as the product of K",
     "elementary reflectors:",
     "      Q = H(1) H(2) . . . H(K) = I - V T V**T",
     "generated using the compact WY representation as returned by DGEQRT.",
     "Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size used for the storage of T.  K >= NB >= 1.",
       "         This must be the same value of NB used to generate T",
       "         in CGEQRT."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension (LDV,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGEQRT in the first K columns of its array argument A."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by CGEQRT, stored as a NB-by-N matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q C, Q**T C, C Q**T or C Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array. The dimension of",
       "         WORK is N*NB if SIDE = 'L', or  M*NB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clasyf_rk"=>
  {"summary"=>
    ["CLASYF_RK computes a partial factorization of a complex symmetric",
     "matrix A using the bounded Bunch-Kaufman (rook) diagonal",
     "pivoting method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**T L21**T )  if UPLO = 'L',",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "CLASYF_RK is an auxiliary routine called by CSYTRF_RK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,N-KB+1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,1:KB).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "W"=>["[out]", "         W is COMPLEX array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "dsytrs_aa"=>
  {"summary"=>
    ["DSYTRS_AA solves a system of linear equations A*X = B with a real",
     "symmetric matrix A using the factorization A = U*T*U**T or",
     "A = L*T*L**T computed by DSYTRF_AA."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*T*U**T;",
       "         = 'L':  Lower triangular, form is A = L*T*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         Details of factors computed by DSYTRF_AA."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges as computed by DSYTRF_AA."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[in]", "         WORK is DOUBLE array, dimension (MAX(1,LWORK))"],
     "LWORK"=>["[in]", "         LWORK is INTEGER, LWORK >= MAX(1,3*N-2)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlasdt"=>
  {"summary"=>
    ["DLASDT creates a tree of subproblems for bidiagonal divide and",
     "conquer."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         On entry, the number of diagonal elements of the",
       "         bidiagonal matrix."],
     "LVL"=>
      ["[out]",
       "         LVL is INTEGER",
       "         On exit, the number of levels on the computation tree."],
     "ND"=>
      ["[out]",
       "         ND is INTEGER",
       "         On exit, the number of nodes on the tree."],
     "INODE"=>
      ["[out]",
       "         INODE is INTEGER array, dimension ( N )",
       "         On exit, centers of subproblems."],
     "NDIML"=>
      ["[out]",
       "         NDIML is INTEGER array, dimension ( N )",
       "         On exit, row dimensions of left children."],
     "NDIMR"=>
      ["[out]",
       "         NDIMR is INTEGER array, dimension ( N )",
       "         On exit, row dimensions of right children."],
     "MSUB"=>
      ["[in]",
       "         MSUB is INTEGER",
       "         On entry, the maximum row dimension each subproblem at the",
       "         bottom of the tree can be of."]}},
 "claqps"=>
  {"summary"=>
    ["CLAQPS computes a step of QR factorization with column pivoting",
     "of a complex M-by-N matrix A by using Blas-3.  It tries to factorize",
     "NB columns from A starting from the row OFFSET+1, and updates all",
     "of the matrix with Blas-3 xGEMM.",
     "In some cases, due to catastrophic cancellations, it cannot",
     "factorize NB columns.  Hence, the actual number of factorized",
     "columns is returned in KB.",
     "Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0"],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         The number of rows of A that have been factorized in",
       "         previous steps."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of columns to factorize."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns actually factorized."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, block A(OFFSET+1:M,1:KB) is the triangular",
       "         factor obtained and block A(1:OFFSET,1:N) has been",
       "         accordingly pivoted, but no factorized.",
       "         The rest of the matrix, block A(OFFSET+1:M,KB+1:N) has",
       "         been updated."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         JPVT(I) = K <==> Column K of the full matrix A has been",
       "         permuted into position I in AP."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (KB)",
       "         The scalar factors of the elementary reflectors."],
     "VN1"=>
      ["[in,out]",
       "         VN1 is REAL array, dimension (N)",
       "         The vector with the partial column norms."],
     "VN2"=>
      ["[in,out]",
       "         VN2 is REAL array, dimension (N)",
       "         The vector with the exact column norms."],
     "AUXV"=>
      ["[in,out]",
       "         AUXV is COMPLEX array, dimension (NB)",
       "         Auxiliar vector."],
     "F"=>
      ["[in,out]",
       "         F is COMPLEX array, dimension (LDF,NB)",
       "         Matrix  F**H = L * Y**H * A."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the array F. LDF >= max(1,N)."]}},
 "dpptrf"=>
  {"summary"=>
    ["DPPTRF computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A stored in packed format.",
     "The factorization has the form",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**T*U or A = L*L**T, in the same",
       "         storage format as A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "clacn2"=>
  {"summary"=>
    ["CLACN2 estimates the 1-norm of a square, complex matrix A.",
     "Reverse communication is used for evaluating matrix-vector products."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The order of the matrix.  N >= 1."],
     "V"=>
      ["[out]",
       "         V is COMPLEX array, dimension (N)",
       "        On the final return, V = A*W,  where  EST = norm(V)/norm(W)",
       "        (W is not returned)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (N)",
       "        On an intermediate return, X should be overwritten by",
       "              A * X,   if KASE=1,",
       "              A**H * X,  if KASE=2,",
       "        where A**H is the conjugate transpose of A, and CLACN2 must be",
       "        re-called with all the other parameters unchanged."],
     "EST"=>
      ["[in,out]",
       "         EST is REAL",
       "        On entry with KASE = 1 or 2 and ISAVE(1) = 3, EST should be",
       "        unchanged from the previous call to CLACN2.",
       "        On exit, EST is an estimate (a lower bound) for norm(A)."],
     "KASE"=>
      ["[in,out]",
       "         KASE is INTEGER",
       "        On the initial call to CLACN2, KASE should be 0.",
       "        On an intermediate return, KASE will be 1 or 2, indicating",
       "        whether X should be overwritten by A * X  or A**H * X.",
       "        On the final return from CLACN2, KASE will again be 0."],
     "ISAVE"=>
      ["[in,out]",
       "         ISAVE is INTEGER array, dimension (3)",
       "        ISAVE is used to save variables between calls to SLACN2"]}},
 "slatbs"=>
  {"summary"=>
    ["SLATBS solves one of the triangular systems",
     "   A *x = s*b  or  A**T*x = s*b",
     "with scaling to prevent overflow, where A is an upper or lower",
     "triangular band matrix.  Here A**T denotes the transpose of A, x and b",
     "are n-element vectors, and s is a scaling factor, usually less than",
     "or equal to 1, chosen so that the components of x will be less than",
     "the overflow threshold.  If the unscaled problem will not cause",
     "overflow, the Level 2 BLAS routine STBSV is called.  If the matrix A",
     "is singular (A(j,j) = 0 for some j), then s is set to 0 and a",
     "non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b  (No transpose)",
       "         = 'T':  Solve A**T* x = s*b  (Transpose)",
       "         = 'C':  Solve A**T* x = s*b  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of subdiagonals or superdiagonals in the",
       "         triangular matrix A.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first KD+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b  or  A**T* x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is REAL array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "sla_porcond"=>
  {"summary"=>
    ["   SLA_PORCOND Estimates the Skeel condition number of  op(A) * op2(C)",
     "   where op2 is determined by CMODE as follows",
     "   CMODE =  1    op2(C) = C",
     "   CMODE =  0    op2(C) = I",
     "   CMODE = -1    op2(C) = inv(C)",
     "   The Skeel condition number  cond(A) = norminf( |inv(A)||A| )",
     "   is computed by computing scaling factors R such that",
     "   diag(R)*A*op2(C) is row equilibrated and computing the standard",
     "   infinity-norm condition number."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is REAL array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by SPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "CMODE"=>
      ["[in]",
       "         CMODE is INTEGER",
       "    Determines op2(C) in the formula op(A) * op2(C) as follows:",
       "    CMODE =  1    op2(C) = C",
       "    CMODE =  0    op2(C) = I",
       "    CMODE = -1    op2(C) = inv(C)"],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The vector C in the formula op(A) * op2(C)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is REAL array, dimension (3*N).",
       "    Workspace."],
     "IWORK"=>
      ["[in]",
       "         IWORK is INTEGER array, dimension (N).",
       "    Workspace."]}},
 "zpstrf"=>
  {"summary"=>
    ["ZPSTRF computes the Cholesky factorization with complete",
     "pivoting of a complex Hermitian positive semidefinite matrix A.",
     "The factorization has the form",
     "   P**T * A * P = U**H * U ,  if UPLO = 'U',",
     "   P**T * A * P = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular, and",
     "P is stored as vector PIV.",
     "This algorithm does not attempt to check that A is positive",
     "semidefinite. This version of the algorithm calls level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization as above."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "PIV"=>
      ["[out]",
       "         PIV is INTEGER array, dimension (N)",
       "         PIV is such that the nonzero entries are P( PIV(K), K ) = 1."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The rank of A given by the number of steps the algorithm",
       "         completed."],
     "TOL"=>
      ["[in]",
       "         TOL is DOUBLE PRECISION",
       "         User defined tolerance. If TOL < 0, then N*U*MAX( A(K,K) )",
       "         will be used. The algorithm terminates at the (K-1)st step",
       "         if the pivot <= TOL."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (2*N)",
       "         Work space."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         < 0: If INFO = -K, the K-th argument had an illegal value,",
       "         = 0: algorithm completed successfully, and",
       "         > 0: the matrix A is either rank deficient with computed rank",
       "              as returned in RANK, or is not positive semidefinite. See",
       "              Section 7 of LAPACK Working Note #161 for further",
       "              information."]}},
 "zsytri_3x"=>
  {"summary"=>
    ["ZSYTRI_3X computes the inverse of a complex symmetric indefinite",
     "matrix A using the factorization computed by ZSYTRF_RK or ZSYTRF_BK:",
     "    A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by ZSYTRF_RK and ZSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the symmetric inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF_RK or ZSYTRF_BK."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX*16 array, dimension (N+NB+1,NB+3)."],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "zunm2l"=>
  {"summary"=>
    ["ZUNM2L overwrites the general complex m-by-n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**H* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**H if SIDE = 'R' and TRANS = 'C',",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by ZGEQLF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left",
       "         = 'R': apply Q or Q**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         ZGEQLF in the last k columns of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGEQLF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaqps"=>
  {"summary"=>
    ["DLAQPS computes a step of QR factorization with column pivoting",
     "of a real M-by-N matrix A by using Blas-3.  It tries to factorize",
     "NB columns from A starting from the row OFFSET+1, and updates all",
     "of the matrix with Blas-3 xGEMM.",
     "In some cases, due to catastrophic cancellations, it cannot",
     "factorize NB columns.  Hence, the actual number of factorized",
     "columns is returned in KB.",
     "Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0"],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         The number of rows of A that have been factorized in",
       "         previous steps."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of columns to factorize."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns actually factorized."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, block A(OFFSET+1:M,1:KB) is the triangular",
       "         factor obtained and block A(1:OFFSET,1:N) has been",
       "         accordingly pivoted, but no factorized.",
       "         The rest of the matrix, block A(OFFSET+1:M,KB+1:N) has",
       "         been updated."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         JPVT(I) = K <==> Column K of the full matrix A has been",
       "         permuted into position I in AP."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (KB)",
       "         The scalar factors of the elementary reflectors."],
     "VN1"=>
      ["[in,out]",
       "         VN1 is DOUBLE PRECISION array, dimension (N)",
       "         The vector with the partial column norms."],
     "VN2"=>
      ["[in,out]",
       "         VN2 is DOUBLE PRECISION array, dimension (N)",
       "         The vector with the exact column norms."],
     "AUXV"=>
      ["[in,out]",
       "         AUXV is DOUBLE PRECISION array, dimension (NB)",
       "         Auxiliar vector."],
     "F"=>
      ["[in,out]",
       "         F is DOUBLE PRECISION array, dimension (LDF,NB)",
       "         Matrix F**T = L*Y**T*A."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the array F. LDF >= max(1,N)."]}},
 "slagtm"=>
  {"summary"=>
    ["SLAGTM performs a matrix-vector product of the form",
     "   B := alpha * A * X + beta * B",
     "where A is a tridiagonal matrix of order N, B and X are N by NRHS",
     "matrices, and alpha and beta are real scalars, each of which may be",
     "0., 1., or -1."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  No transpose, B := alpha * A * X + beta * B",
       "         = 'T':  Transpose,    B := alpha * A'* X + beta * B",
       "         = 'C':  Conjugate transpose = Transpose"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices X and B."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "         The scalar alpha.  ALPHA must be 0., 1., or -1.; otherwise,",
       "         it is assumed to be 0."],
     "DL"=>
      ["[in]",
       "         DL is REAL array, dimension (N-1)",
       "         The (n-1) sub-diagonal elements of T."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of T."],
     "DU"=>
      ["[in]",
       "         DU is REAL array, dimension (N-1)",
       "         The (n-1) super-diagonal elements of T."],
     "X"=>
      ["[in]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         The N by NRHS matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(N,1)."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL",
       "         The scalar beta.  BETA must be 0., 1., or -1.; otherwise,",
       "         it is assumed to be 1."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N by NRHS matrix B.",
       "         On exit, B is overwritten by the matrix expression",
       "         B := alpha * A * X + beta * B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(N,1)."]}},
 "cggsvp3"=>
  {"summary"=>
    ["CGGSVP3 computes unitary matrices U, V and Q such that",
     "                   N-K-L  K    L",
     " U**H*A*Q =     K ( 0    A12  A13 )  if M-K-L >= 0;",
     "                L ( 0     0   A23 )",
     "            M-K-L ( 0     0    0  )",
     "                 N-K-L  K    L",
     "        =     K ( 0    A12  A13 )  if M-K-L < 0;",
     "            M-K ( 0     0   A23 )",
     "                 N-K-L  K    L",
     " V**H*B*Q =   L ( 0     0   B13 )",
     "            P-L ( 0     0    0  )",
     "where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular",
     "upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,",
     "otherwise A23 is (M-K)-by-L upper trapezoidal.  K+L = the effective",
     "numerical rank of the (M+P)-by-N matrix (A**H,B**H)**H.",
     "This decomposition is the preprocessing step for computing the",
     "Generalized Singular Value Decomposition (GSVD), see subroutine",
     "CGGSVD3."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  Unitary matrix U is computed;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  Unitary matrix V is computed;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Unitary matrix Q is computed;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A contains the triangular (or trapezoidal) matrix",
       "         described in the Purpose section."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, B contains the triangular matrix described in",
       "         the Purpose section."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TOLA"=>["[in]", "         TOLA is REAL"],
     "TOLB"=>
      ["[in]",
       "         TOLB is REAL",
       "         TOLA and TOLB are the thresholds to determine the effective",
       "         numerical rank of matrix B and a subblock of A. Generally,",
       "         they are set to",
       "            TOLA = MAX(M,N)*norm(A)*MACHEPS,",
       "            TOLB = MAX(P,N)*norm(B)*MACHEPS.",
       "         The size of TOLA and TOLB may affect the size of backward",
       "         errors of the decomposition."],
     "K"=>["[out]", "         K is INTEGER"],
     "L"=>
      ["[out]",
       "         L is INTEGER",
       "         On exit, K and L specify the dimension of the subblocks",
       "         described in Purpose section.",
       "         K + L = effective numerical rank of (A**H,B**H)**H."],
     "U"=>
      ["[out]",
       "         U is COMPLEX array, dimension (LDU,M)",
       "         If JOBU = 'U', U contains the unitary matrix U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[out]",
       "         V is COMPLEX array, dimension (LDV,P)",
       "         If JOBV = 'V', V contains the unitary matrix V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX array, dimension (LDQ,N)",
       "         If JOBQ = 'Q', Q contains the unitary matrix Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "TAU"=>["[out]", "         TAU is COMPLEX array, dimension (N)"],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "sgbequ"=>
  {"summary"=>
    ["SGBEQU computes row and column scalings intended to equilibrate an",
     "M-by-N band matrix A and reduce its condition number.  R returns the",
     "row scale factors and C the column scale factors, chosen to try to",
     "make the largest element in each row and column of the matrix B with",
     "elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.",
     "R(i) and C(j) are restricted to be between SMLNUM = smallest safe",
     "number and BIGNUM = largest safe number.  Use of these scaling",
     "factors is not guaranteed to reduce the condition number of A but",
     "works well in practice."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The band matrix A, stored in rows 1 to KL+KU+1.  The j-th",
       "         column of A is stored in the j-th column of the array AB as",
       "         follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "R"=>
      ["[out]",
       "         R is REAL array, dimension (M)",
       "         If INFO = 0, or INFO > M, R contains the row scale factors",
       "         for A."],
     "C"=>
      ["[out]",
       "         C is REAL array, dimension (N)",
       "         If INFO = 0, C contains the column scale factors for A."],
     "ROWCND"=>
      ["[out]",
       "         ROWCND is REAL",
       "         If INFO = 0 or INFO > M, ROWCND contains the ratio of the",
       "         smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and",
       "         AMAX is neither too large nor too small, it is not worth",
       "         scaling by R."],
     "COLCND"=>
      ["[out]",
       "         COLCND is REAL",
       "         If INFO = 0, COLCND contains the ratio of the smallest",
       "         C(i) to the largest C(i).  If COLCND >= 0.1, it is not",
       "         worth scaling by C."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is",
       "               <= M:  the i-th row of A is exactly zero",
       "               >  M:  the (i-M)-th column of A is exactly zero"]}},
 "sstevx"=>
  {"summary"=>
    ["SSTEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix A.  Eigenvalues and",
     "eigenvectors can be selected by specifying either a range of values",
     "or a range of indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.",
       "         On exit, D may be multiplied by a constant factor chosen",
       "         to avoid over/underflow in computing the eigenvalues."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (max(1,N-1))",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A in elements 1 to N-1 of E.",
       "         On exit, E may be multiplied by a constant factor chosen",
       "         to avoid over/underflow in computing the eigenvalues."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less",
       "         than or equal to zero, then  EPS*|T|  will be used in",
       "         its place, where |T| is the 1-norm of the tridiagonal",
       "         matrix.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge (INFO > 0), then that",
       "         column of Z contains the latest approximation to the",
       "         eigenvector, and the index of the eigenvector is returned",
       "         in IFAIL.  If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (5*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "cgerfs"=>
  {"summary"=>
    ["CGERFS improves the computed solution to a system of linear",
     "equations and provides error bounds and backward error estimates for",
     "the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The original N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by CGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from CGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by CGETRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "icmax1"=>
  {"summary"=>
    ["ICMAX1 finds the index of the first vector element of maximum absolute value.",
     "Based on ICAMAX from Level 1 BLAS.",
     "The change is to use the 'genuine' absolute value."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements in the vector CX."],
     "CX"=>
      ["[in]",
       "         CX is COMPLEX array, dimension (N)",
       "         The vector CX. The ICMAX1 function returns the index of its first",
       "         element of maximum absolute value."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The spacing between successive values of CX.  INCX >= 1."]}},
 "dormql"=>
  {"summary"=>
    ["DORMQL overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by DGEQLF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGEQLF in the last k columns of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGEQLF."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgbrfsx"=>
  {"summary"=>
    ["   SGBRFSX improves the computed solution to a system of linear",
     "   equations and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED, R",
     "   and C below. In this case, the solution and error bounds returned",
     "   are for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "              diag(R).",
       "      = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "              by diag(C).",
       "      = 'B':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(R) * A * diag(C).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "    The original band matrix A, stored in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is REAL array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by DGBTRF.  U is stored as an upper triangular band",
       "    matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "    the multipliers used during the factorization are stored in",
       "    rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL*KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from SGETRF; for 1<=i<=N, row i of the",
       "    matrix was interchanged with row IPIV(i)."],
     "R"=>
      ["[in,out]",
       "         R is REAL array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'R' or 'B', A is",
       "    multiplied on the left by diag(R); if EQUED = 'N' or 'C', R",
       "    is not accessed.  R is an input argument if FACT = 'F';",
       "    otherwise, R is an output argument.  If FACT = 'F' and",
       "    EQUED = 'R' or 'B', each element of R must be positive.",
       "    If R is output, each element of R is a power of the radix.",
       "    If R is input, each element of R should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A.  If EQUED = 'C' or 'B', A is",
       "    multiplied on the right by diag(C); if EQUED = 'N' or 'R', C",
       "    is not accessed.  C is an input argument if FACT = 'F';",
       "    otherwise, C is an output argument.  If FACT = 'F' and",
       "    EQUED = 'C' or 'B', each element of C must be positive.",
       "    If C is output, each element of C is a power of the radix.",
       "    If C is input, each element of C should be a power of the radix",
       "    to ensure a reliable solution and error estimates. Scaling by",
       "    powers of the radix does not cause rounding errors unless the",
       "    result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by SGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is REAL array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "zhecon_3"=>
  {"summary"=>
    ["ZHECON_3 estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex Hermitian matrix A using the factorization",
     "computed by ZHETRF_RK or ZHETRF_BK:",
     "   A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).",
     "This routine uses BLAS3 solver ZHETRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix:",
       "         = 'U':  Upper triangular, form is A = P*U*D*(U**H)*(P**T);",
       "         = 'L':  Lower triangular, form is A = P*L*D*(L**H)*(P**T)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         Diagonal of the block diagonal matrix D and factors U or L",
       "         as computed by ZHETRF_RK and ZHETRF_BK:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHETRF_RK or ZHETRF_BK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlasyf_rook"=>
  {"summary"=>
    ["DLASYF_ROOK computes a partial factorization of a real symmetric",
     "matrix A using the bounded Bunch-Kaufman (\"rook\") diagonal",
     "pivoting method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**T L21**T )  if UPLO = 'L'",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "DLASYF_ROOK is an auxiliary routine called by DSYTRF_ROOK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "W"=>
      ["[out]", "         W is DOUBLE PRECISION array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "zla_porfsx_extended"=>
  {"summary"=>
    ["ZLA_PORFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by ZPORFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by ZPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension",
       "                   (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by ZPOTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by ZLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is DOUBLE PRECISION array, dimension (N)",
       "    Workspace."],
     "DY"=>
      ["[in]",
       "         DY is COMPLEX*16 PRECISION array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is DOUBLE PRECISION",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is DOUBLE PRECISION",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to ZPOTRS had an illegal",
       "            value"]}},
 "spptri"=>
  {"summary"=>
    ["SPPTRI computes the inverse of a real symmetric positive definite",
     "matrix A using the Cholesky factorization A = U**T*U or A = L*L**T",
     "computed by SPPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor is stored in AP;",
       "         = 'L':  Lower triangular factor is stored in AP."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the triangular factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T, packed columnwise as",
       "         a linear array.  The j-th column of U or L is stored in the",
       "         array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n.",
       "         On exit, the upper or lower triangle of the (symmetric)",
       "         inverse of A, overwriting the input factor U or L."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "ssytrd"=>
  {"summary"=>
    ["SSYTRD reduces a real symmetric matrix A to real symmetric",
     "tridiagonal form T by an orthogonal similarity transformation:",
     "Q**T * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the orthogonal",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the orthogonal matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= 1.",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slartgp"=>
  {"summary"=>
    ["SLARTGP generates a plane rotation so that",
     "   [  CS  SN  ]  .  [ F ]  =  [ R ]   where CS**2 + SN**2 = 1.",
     "   [ -SN  CS  ]     [ G ]     [ 0 ]",
     "This is a slower, more accurate version of the Level 1 BLAS routine SROTG,",
     "with the following other differences:",
     "   F and G are unchanged on return.",
     "   If G=0, then CS=(+/-)1 and SN=0.",
     "   If F=0 and (G .ne. 0), then CS=0 and SN=(+/-)1.",
     "The sign is chosen so that R >= 0."],
   "param"=>
    {"F"=>
      ["[in]",
       "         F is REAL",
       "         The first component of vector to be rotated."],
     "G"=>
      ["[in]",
       "         G is REAL",
       "         The second component of vector to be rotated."],
     "CS"=>
      ["[out]", "         CS is REAL", "         The cosine of the rotation."],
     "SN"=>
      ["[out]", "         SN is REAL", "         The sine of the rotation."],
     "R"=>
      ["[out]",
       "         R is REAL",
       "         The nonzero component of the rotated vector.",
       " This version has a few statements commented out for thread safety",
       " (machine parameters are computed on each entry). 10 feb 03, SJH."]}},
 "chetrf_aa"=>
  {"summary"=>
    ["CHETRF_AA computes the factorization of a complex hermitian matrix A",
     "using the Aasen's algorithm.  The form of the factorization is",
     "   A = U*T*U**H  or  A = L*T*L**H",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is a hermitian tridiagonal matrix.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the tridiagonal matrix is stored in the diagonals",
       "         and the subdiagonals of A just below (or above) the diagonals,",
       "         and L is stored below (or above) the subdiaonals, when UPLO",
       "         is 'L' (or 'U')."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 2*N. For optimum performance",
       "         LWORK >= N*(1+NB), where NB is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "chb2st_kernels"=>
  {"summary"=>
    ["CHB2ST_KERNELS is an internal routine used by the CHETRD_HB2ST",
     "subroutine."],
   "param"=>nil},
 "zsyequb"=>
  {"summary"=>
    ["ZSYEQUB computes row and column scalings intended to equilibrate a",
     "symmetric matrix A (with respect to the Euclidean norm) and reduce",
     "its condition number. The scale factors S are computed by the BIN",
     "algorithm (see references) so that the scaled matrix B with elements",
     "B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of",
     "the smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The N-by-N symmetric matrix whose scaling factors are to be",
       "         computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is DOUBLE PRECISION",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i). If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Largest absolute value of any matrix element. If AMAX is",
       "         very close to overflow or very close to underflow, the",
       "         matrix should be scaled."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "cstegr"=>
  {"summary"=>
    ["CSTEGR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix T. Any such unreduced matrix has",
     "a well defined set of pairwise different real eigenvalues, the corresponding",
     "real eigenvectors are pairwise orthogonal.",
     "The spectrum may be computed either completely or partially by specifying",
     "either an interval (VL,VU] or a range of indices IL:IU for the desired",
     "eigenvalues.",
     "CSTEGR is a compatibility wrapper around the improved CSTEMR routine.",
     "See SSTEMR for further details.",
     "One important change is that the ABSTOL parameter no longer provides any",
     "benefit and hence is no longer used.",
     "Note : CSTEGR and CSTEMR work only on machines which follow",
     "IEEE-754 floating-point standard in their handling of infinities and",
     "NaNs.  Normal execution may create these exceptiona values and hence",
     "may abort due to a floating point exception in environments which",
     "do not conform to the IEEE-754 standard."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal matrix",
       "         T. On exit, D is overwritten."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the tridiagonal",
       "         matrix T in elements 1 to N-1 of E. E(N) need not be set on",
       "         input, but is used internally as workspace.",
       "         On exit, E is overwritten."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         Unused.  Was the absolute error tolerance for the",
       "         eigenvalues/eigenvectors in previous versions."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', and if INFO = 0, then the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix T",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used.",
       "         Supplying N columns is always safe."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', then LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER ARRAY, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th computed eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is relevant in the case when the matrix",
       "         is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal",
       "         (and minimal) LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,18*N)",
       "         if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (LIWORK)",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N)",
       "         if the eigenvectors are desired, and LIWORK >= max(1,8*N)",
       "         if only the eigenvalues are to be computed.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = 1X, internal error in SLARRE,",
       "               if INFO = 2X, internal error in CLARRV.",
       "               Here, the digit X = ABS( IINFO ) < 10, where IINFO is",
       "               the nonzero error code returned by SLARRE or",
       "               CLARRV, respectively."]}},
 "zgeqrfp"=>
  {"summary"=>
    ["ZGEQRFP computes a QR factorization of a complex M-by-N matrix A:",
     "A = Q * R. The diagonal entries of R are real and nonnegative."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n). The diagonal entries of R",
       "         are real and nonnegative; The elements below the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of min(m,n) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chegst"=>
  {"summary"=>
    ["CHEGST reduces a complex Hermitian-definite generalized",
     "eigenproblem to standard form.",
     "If ITYPE = 1, the problem is A*x = lambda*B*x,",
     "and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)",
     "If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or",
     "B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L.",
     "B must have been previously factorized as U**H*U or L*L**H by CPOTRF."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H);",
       "         = 2 or 3: compute U*A*U**H or L**H*A*L."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored and B is factored as",
       "                 U**H*U;",
       "         = 'L':  Lower triangle of A is stored and B is factored as",
       "                 L*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the transformed matrix, stored in the",
       "         same format as A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         The triangular factor from the Cholesky factorization of B,",
       "         as returned by CPOTRF."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ctfttp"=>
  {"summary"=>
    ["CTFTTP copies a triangular matrix A from rectangular full packed",
     "format (TF) to standard packed format (TP)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF is in Normal format;",
       "         = 'C':  ARF is in Conjugate-transpose format;"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "ARF"=>
      ["[in]",
       "         ARF is COMPLEX array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "AP"=>
      ["[out]",
       "         AP is COMPLEX array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cpbcon"=>
  {"summary"=>
    ["CPBCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex Hermitian positive definite band matrix using",
     "the Cholesky factorization A = U**H*U or A = L*L**H computed by",
     "CPBTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor stored in AB;",
       "         = 'L':  Lower triangular factor stored in AB."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H of the band matrix A, stored in the",
       "         first KD+1 rows of the array.  The j-th column of U or L is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO ='U', AB(kd+1+i-j,j) = U(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO ='L', AB(1+i-j,j)    = L(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm (or infinity-norm) of the Hermitian band matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "claqhe"=>
  {"summary"=>
    ["CLAQHE equilibrates a Hermitian matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if EQUED = 'Y', the equilibrated matrix:",
       "         diag(S) * A * diag(S)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is REAL",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "dgeevx"=>
  {"summary"=>
    ["DGEEVX computes for an N-by-N real nonsymmetric matrix A, the",
     "eigenvalues and, optionally, the left and/or right eigenvectors.",
     "Optionally also, it computes a balancing transformation to improve",
     "the conditioning of the eigenvalues and eigenvectors (ILO, IHI,",
     "SCALE, and ABNRM), reciprocal condition numbers for the eigenvalues",
     "(RCONDE), and reciprocal condition numbers for the right",
     "eigenvectors (RCONDV).",
     "The right eigenvector v(j) of A satisfies",
     "                 A * v(j) = lambda(j) * v(j)",
     "where lambda(j) is its eigenvalue.",
     "The left eigenvector u(j) of A satisfies",
     "              u(j)**H * A = lambda(j) * u(j)**H",
     "where u(j)**H denotes the conjugate-transpose of u(j).",
     "The computed eigenvectors are normalized to have Euclidean norm",
     "equal to 1 and largest component real.",
     "Balancing a matrix means permuting the rows and columns to make it",
     "more nearly upper triangular, and applying a diagonal similarity",
     "transformation D * A * D**(-1), where D is a diagonal matrix, to",
     "make its rows and columns closer in norm and the condition numbers",
     "of its eigenvalues and eigenvectors smaller.  The computed",
     "reciprocal condition numbers correspond to the balanced matrix.",
     "Permuting rows and columns will not change the condition numbers",
     "(in exact arithmetic) but diagonal scaling will.  For further",
     "explanation of balancing, see section 4.10.2 of the LAPACK",
     "Users' Guide."],
   "param"=>
    {"BALANC"=>
      ["[in]",
       "         BALANC is CHARACTER*1",
       "         Indicates how the input matrix should be diagonally scaled",
       "         and/or permuted to improve the conditioning of its",
       "         eigenvalues.",
       "         = 'N': Do not diagonally scale or permute;",
       "         = 'P': Perform permutations to make the matrix more nearly",
       "                upper triangular. Do not diagonally scale;",
       "         = 'S': Diagonally scale the matrix, i.e. replace A by",
       "                D*A*D**(-1), where D is a diagonal matrix chosen",
       "                to make the rows and columns of A more equal in",
       "                norm. Do not permute;",
       "         = 'B': Both diagonally scale and permute A.",
       "         Computed reciprocal condition numbers will be for the matrix",
       "         after balancing and/or permuting. Permuting does not change",
       "         condition numbers (in exact arithmetic), but balancing does."],
     "JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N': left eigenvectors of A are not computed;",
       "         = 'V': left eigenvectors of A are computed.",
       "         If SENSE = 'E' or 'B', JOBVL must = 'V'."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N': right eigenvectors of A are not computed;",
       "         = 'V': right eigenvectors of A are computed.",
       "         If SENSE = 'E' or 'B', JOBVR must = 'V'."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': None are computed;",
       "         = 'E': Computed for eigenvalues only;",
       "         = 'V': Computed for right eigenvectors only;",
       "         = 'B': Computed for eigenvalues and right eigenvectors.",
       "         If SENSE = 'E' or 'B', both left and right eigenvectors",
       "         must also be computed (JOBVL = 'V' and JOBVR = 'V')."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten.  If JOBVL = 'V' or",
       "         JOBVR = 'V', A contains the real Schur form of the balanced",
       "         version of the input matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "WR"=>["[out]", "         WR is DOUBLE PRECISION array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is DOUBLE PRECISION array, dimension (N)",
       "         WR and WI contain the real and imaginary parts,",
       "         respectively, of the computed eigenvalues.  Complex",
       "         conjugate pairs of eigenvalues will appear consecutively",
       "         with the eigenvalue having the positive imaginary part",
       "         first."],
     "VL"=>
      ["[out]",
       "         VL is DOUBLE PRECISION array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order",
       "         as their eigenvalues.",
       "         If JOBVL = 'N', VL is not referenced.",
       "         If the j-th eigenvalue is real, then u(j) = VL(:,j),",
       "         the j-th column of VL.",
       "         If the j-th and (j+1)-st eigenvalues form a complex",
       "         conjugate pair, then u(j) = VL(:,j) + i*VL(:,j+1) and",
       "         u(j+1) = VL(:,j) - i*VL(:,j+1)."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1; if",
       "         JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is DOUBLE PRECISION array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order",
       "         as their eigenvalues.",
       "         If JOBVR = 'N', VR is not referenced.",
       "         If the j-th eigenvalue is real, then v(j) = VR(:,j),",
       "         the j-th column of VR.",
       "         If the j-th and (j+1)-st eigenvalues form a complex",
       "         conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and",
       "         v(j+1) = VR(:,j) - i*VR(:,j+1)."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1, and if",
       "         JOBVR = 'V', LDVR >= N."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are integer values determined when A was",
       "         balanced.  The balanced A(i,j) = 0 if I > J and",
       "         J = 1,...,ILO-1 or I = IHI+1,...,N."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         when balancing A.  If P(j) is the index of the row and column",
       "         interchanged with row and column j, and D(j) is the scaling",
       "         factor applied to row and column j, then",
       "         SCALE(J) = P(J),    for J = 1,...,ILO-1",
       "                  = D(J),    for J = ILO,...,IHI",
       "                  = P(J)     for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "ABNRM"=>
      ["[out]",
       "         ABNRM is DOUBLE PRECISION",
       "         The one-norm of the balanced matrix (the maximum",
       "         of the sum of absolute values of elements of any column)."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is DOUBLE PRECISION array, dimension (N)",
       "         RCONDE(j) is the reciprocal condition number of the j-th",
       "         eigenvalue."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is DOUBLE PRECISION array, dimension (N)",
       "         RCONDV(j) is the reciprocal condition number of the j-th",
       "         right eigenvector."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.   If SENSE = 'N' or 'E',",
       "         LWORK >= max(1,2*N), and if JOBVL = 'V' or JOBVR = 'V',",
       "         LWORK >= 3*N.  If SENSE = 'V' or 'B', LWORK >= N*(N+6).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (2*N-2)",
       "         If SENSE = 'N' or 'E', not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the QR algorithm failed to compute all the",
       "               eigenvalues, and no eigenvectors or condition numbers",
       "               have been computed; elements 1:ILO-1 and i+1:N of WR",
       "               and WI contain eigenvalues which have converged."]}},
 "ssytri_rook"=>
  {"summary"=>
    ["SSYTRI_ROOK computes the inverse of a real symmetric",
     "matrix A using the factorization A = U*D*U**T or A = L*D*L**T",
     "computed by SSYTRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by SSYTRF_ROOK.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF_ROOK."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "slaqtr"=>
  {"summary"=>
    ["SLAQTR solves the real quasi-triangular system",
     "             op(T)*p = scale*c,               if LREAL = .TRUE.",
     "or the complex quasi-triangular systems",
     "           op(T + iB)*(p+iq) = scale*(c+id),  if LREAL = .FALSE.",
     "in real arithmetic, where T is upper quasi-triangular.",
     "If LREAL = .FALSE., then the first diagonal block of T must be",
     "1 by 1, B is the specially structured matrix",
     "               B = [ b(1) b(2) ... b(n) ]",
     "                   [       w            ]",
     "                   [           w        ]",
     "                   [              .     ]",
     "                   [                 w  ]",
     "op(A) = A or A**T, A**T denotes the transpose of",
     "matrix A.",
     "On input, X = [ c ].  On output, X = [ p ].",
     "              [ d ]                  [ q ]",
     "This subroutine is designed for the condition number estimation",
     "in routine STRSNA."],
   "param"=>
    {"LTRAN"=>
      ["[in]",
       "         LTRAN is LOGICAL",
       "         On entry, LTRAN specifies the option of conjugate transpose:",
       "            = .FALSE.,    op(T+i*B) = T+i*B,",
       "            = .TRUE.,     op(T+i*B) = (T+i*B)**T."],
     "LREAL"=>
      ["[in]",
       "         LREAL is LOGICAL",
       "         On entry, LREAL specifies the input matrix structure:",
       "            = .FALSE.,    the input is complex",
       "            = .TRUE.,     the input is real"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         On entry, N specifies the order of T+i*B. N >= 0."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (LDT,N)",
       "         On entry, T contains a matrix in Schur canonical form.",
       "         If LREAL = .FALSE., then the first diagonal block of T must",
       "         be 1 by 1."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the matrix T. LDT >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (N)",
       "         On entry, B contains the elements to form the matrix",
       "         B as described above.",
       "         If LREAL = .TRUE., B is not referenced."],
     "W"=>
      ["[in]",
       "         W is REAL",
       "         On entry, W is the diagonal element of the matrix B.",
       "         If LREAL = .TRUE., W is not referenced."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         On exit, SCALE is the scale factor."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (2*N)",
       "         On entry, X contains the right hand side of the system.",
       "         On exit, X is overwritten by the solution."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO is set to",
       "            0: successful exit.",
       "              1: the some diagonal 1 by 1 block has been perturbed by",
       "                 a small number SMIN to keep nonsingularity.",
       "              2: the some diagonal 2 by 2 block has been perturbed by",
       "                 a small number in SLALN2 to keep nonsingularity.",
       "         NOTE: In the interests of speed, this routine does not",
       "               check the inputs for errors."]}},
 "cla_gbrfsx_extended"=>
  {"summary"=>
    ["CLA_GBRFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by CGBRFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "TRANS_TYPE"=>
      ["[in]",
       "         TRANS_TYPE is INTEGER",
       "    Specifies the transposition operation on A.",
       "    The value is defined by ILATRANS(T) where T is a CHARACTER and",
       "    T    = 'N':  No transpose",
       "         = 'T':  Transpose",
       "         = 'C':  Conjugate transpose"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0"],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "    On entry, the N-by-N matrix AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= max(1,N)."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by CGBTRF."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by CGBTRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by CGBTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is REAL array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by CLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is REAL array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is REAL array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]", "         AYB is REAL array, dimension (N)", "    Workspace."],
     "DY"=>
      ["[in]",
       "         DY is COMPLEX array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is COMPLEX array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is REAL",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is REAL",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to CGBTRS had an illegal",
       "            value"]}},
 "ctrttf"=>
  {"summary"=>
    ["CTRTTF copies a triangular matrix A from standard full format (TR)",
     "to rectangular full packed format (TF) ."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF in Normal mode is wanted;",
       "         = 'C':  ARF in Conjugate Transpose mode is wanted;"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension ( LDA, N )",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the matrix A.  LDA >= max(1,N)."],
     "ARF"=>
      ["[out]",
       "         ARF is COMPLEX array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chesv_rk"=>
  {"summary"=>
    ["CHESV_RK computes the solution to a complex system of linear",
     "equations A * X = B, where A is an N-by-N Hermitian matrix",
     "and X and B are N-by-NRHS matrices.",
     "The bounded Bunch-Kaufman (rook) diagonal pivoting method is used",
     "to factor A as",
     "   A = P*U*D*(U**H)*(P**T),  if UPLO = 'U', or",
     "   A = P*L*D*(L**H)*(P**T),  if UPLO = 'L',",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "CHETRF_RK is called to compute the factorization of a complex",
     "Hermitian matrix.  The factored form of A is then used to solve",
     "the system of equations A * X = B by calling BLAS3 routine CHETRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, if INFO = 0, diagonal of the block diagonal",
       "         matrix D and factors U or L  as computed by CHETRF_RK:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         For more info see the description of CHETRF_RK routine."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX array, dimension (N)",
       "         On exit, contains the output computed by the factorization",
       "         routine CHETRF_RK, i.e. the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases.",
       "         For more info see the description of CHETRF_RK routine."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D,",
       "         as determined by CHETRF_RK.",
       "         For more info see the description of CHETRF_RK routine."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension ( MAX(1,LWORK) ).",
       "         Work array used in the factorization stage.",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1. For best performance",
       "         of factorization stage LWORK >= max(1,N*NB), where NB is",
       "         the optimal blocksize for CHETRF_RK.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array for factorization stage, returns this value as",
       "         the first entry of the WORK array, and no error message",
       "         related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "iladlr"=>
  {"summary"=>["ILADLR scans A for its last non-zero row."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."]}},
 "dgsvj1"=>
  {"summary"=>
    ["DGSVJ1 is called from DGESVJ as a pre-processor and that is its main",
     "purpose. It applies Jacobi rotations in the same way as DGESVJ does, but",
     "it targets only particular pivots and it does not check convergence",
     "(stopping criterion). Few tunning parameters (marked by [TP]) are",
     "available for the implementer.",
     "Further Details",
     "~~~~~~~~~~~~~~~",
     "DGSVJ1 applies few sweeps of Jacobi rotations in the column space of",
     "the input M-by-N matrix A. The pivot pairs are taken from the (1,2)",
     "off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The",
     "block-entries (tiles) of the (1,2) off-diagonal block are marked by the",
     "[x]'s in the following scheme:",
     "   | *  *  * [x] [x] [x]|",
     "   | *  *  * [x] [x] [x]|    Row-cycling in the nblr-by-nblc [x] blocks.",
     "   | *  *  * [x] [x] [x]|    Row-cyclic pivoting inside each [x] block.",
     "   |[x] [x] [x] *  *  * |",
     "   |[x] [x] [x] *  *  * |",
     "   |[x] [x] [x] *  *  * |",
     "In terms of the columns of A, the first N1 columns are rotated 'against'",
     "the remaining N-N1 columns, trying to increase the angle between the",
     "corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is",
     "tiled using quadratic tiles of side KBL. Here, KBL is a tunning parmeter.",
     "The number of sweeps is given in NSWEEP and the orthogonality threshold",
     "is given in TOL."],
   "param"=>
    {"JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether the output from this procedure is used",
       "         to compute the matrix V:",
       "         = 'V': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the N-by-N array V.",
       "               (See the description of V.)",
       "         = 'A': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the MV-by-N array V.",
       "               (See the descriptions of MV and V.)",
       "         = 'N': the Jacobi rotations are not accumulated."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         N1 specifies the 2 x 2 block partition, the first N1 columns are",
       "         rotated 'against' the remaining N-N1 columns of A."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, M-by-N matrix A, such that A*diag(D) represents",
       "         the input matrix.",
       "         On exit,",
       "         A_onexit * D_onexit represents the input matrix A*diag(D)",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of N1, D, TOL and NSWEEP.)"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The array D accumulates the scaling factors from the fast scaled",
       "         Jacobi rotations.",
       "         On entry, A*diag(D) represents the input matrix.",
       "         On exit, A_onexit*diag(D_onexit) represents the input matrix",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of N1, A, TOL and NSWEEP.)"],
     "SVA"=>
      ["[in,out]",
       "         SVA is DOUBLE PRECISION array, dimension (N)",
       "         On entry, SVA contains the Euclidean norms of the columns of",
       "         the matrix A*diag(D).",
       "         On exit, SVA contains the Euclidean norms of the columns of",
       "         the matrix onexit*diag(D_onexit)."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then MV is not referenced."],
     "V"=>
      ["[in,out]",
       "         V is DOUBLE PRECISION array, dimension (LDV,N)",
       "         If JOBV .EQ. 'V' then N rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV .EQ. 'A' then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V', LDV .GE. N.",
       "         If JOBV = 'A', LDV .GE. MV."],
     "EPS"=>
      ["[in]",
       "         EPS is DOUBLE PRECISION",
       "         EPS = DLAMCH('Epsilon')"],
     "SFMIN"=>
      ["[in]",
       "         SFMIN is DOUBLE PRECISION",
       "         SFMIN = DLAMCH('Safe Minimum')"],
     "TOL"=>
      ["[in]",
       "         TOL is DOUBLE PRECISION",
       "         TOL is the threshold for Jacobi rotations. For a pair",
       "         A(:,p), A(:,q) of pivot columns, the Jacobi rotation is",
       "         applied only if DABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL."],
     "NSWEEP"=>
      ["[in]",
       "         NSWEEP is INTEGER",
       "         NSWEEP is the number of sweeps of Jacobi rotations to be",
       "         performed."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         LWORK is the dimension of WORK. LWORK .GE. M."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value"]}},
 "dlapy3"=>
  {"summary"=>
    ["DLAPY3 returns sqrt(x**2+y**2+z**2), taking care not to cause",
     "unnecessary overflow."],
   "param"=>
    {"X"=>["[in]", "         X is DOUBLE PRECISION"],
     "Y"=>["[in]", "         Y is DOUBLE PRECISION"],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION",
       "         X, Y and Z specify the values x, y and z."]}},
 "clanhs"=>
  {"summary"=>
    ["CLANHS  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "Hessenberg matrix A.",
     "   CLANHS = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANHS as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANHS is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The n by n upper Hessenberg matrix A; the part of A below the",
       "         first sub-diagonal is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "zlamswlq"=>
  {"summary"=>
    ["   ZLAMQRTS overwrites the general real M-by-N matrix C with",
     "                   SIDE = 'L'     SIDE = 'R'",
     "   TRANS = 'N':      Q * C          C * Q",
     "   TRANS = 'T':      Q**T * C       C * Q**T",
     "   where Q is a real orthogonal matrix defined as the product of blocked",
     "   elementary reflectors computed by short wide LQ",
     "   factorization (ZLASWLQ)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         M >= K >= 0;"],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         M >= MB >= 1"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.",
       "               MB > M."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,K)",
       "         The i-th row must contain the vector which defines the blocked",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DLASWLQ in the first k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension",
       "         ( M * Number of blocks(CEIL(N-K/NB-K)),",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "        (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,NB) * MB;",
       "         if SIDE = 'R', LWORK >= max(1,M) * MB.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cungqr"=>
  {"summary"=>
    ["CUNGQR generates an M-by-N complex matrix Q with orthonormal columns,",
     "which is defined as the first N columns of a product of K elementary",
     "reflectors of order M",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by CGEQRF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the i-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by CGEQRF in the first k columns of its array",
       "         argument A.",
       "         On exit, the M-by-N matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGEQRF."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument has an illegal value"]}},
 "zstemr"=>
  {"summary"=>
    ["ZSTEMR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix T. Any such unreduced matrix has",
     "a well defined set of pairwise different real eigenvalues, the corresponding",
     "real eigenvectors are pairwise orthogonal.",
     "The spectrum may be computed either completely or partially by specifying",
     "either an interval (VL,VU] or a range of indices IL:IU for the desired",
     "eigenvalues.",
     "Depending on the number of desired eigenvalues, these are computed either",
     "by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are",
     "computed by the use of various suitable L D L^T factorizations near clusters",
     "of close eigenvalues (referred to as RRRs, Relatively Robust",
     "Representations). An informal sketch of the algorithm follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "For more details, see:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Further Details",
     "1.ZSTEMR works only on machines which follow IEEE-754",
     "floating-point standard in their handling of infinities and NaNs.",
     "This permits the use of efficient inner loops avoiding a check for",
     "zero divisors.",
     "2. LAPACK routines can be used to reduce a complex Hermitean matrix to",
     "real symmetric tridiagonal form.",
     "(Any complex Hermitean tridiagonal matrix has real values on its diagonal",
     "and potentially complex numbers on its off-diagonals. By applying a",
     "similarity transform with an appropriate diagonal matrix",
     "diag(1,e^{i \\phy_1}, ... , e^{i \\phy_{n-1}}), the complex Hermitean",
     "matrix can be transformed into a real symmetric matrix and complex",
     "arithmetic can be entirely avoided.)",
     "While the eigenvectors of the real symmetric tridiagonal matrix are real,",
     "the eigenvectors of original complex Hermitean matrix have complex entries",
     "in general.",
     "Since LAPACK drivers overwrite the matrix data with the eigenvectors,",
     "ZSTEMR accepts complex workspace to facilitate interoperability",
     "with ZUNMTR or ZUPMTR."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal matrix",
       "         T. On exit, D is overwritten."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the tridiagonal",
       "         matrix T in elements 1 to N-1 of E. E(N) need not be set on",
       "         input, but is used internally as workspace.",
       "         On exit, E is overwritten."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', and if INFO = 0, then the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix T",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and can be computed with a workspace",
       "         query by setting NZC = -1, see below."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', then LDZ >= max(1,N)."],
     "NZC"=>
      ["[in]",
       "         NZC is INTEGER",
       "         The number of eigenvectors to be held in the array Z.",
       "         If RANGE = 'A', then NZC >= max(1,N).",
       "         If RANGE = 'V', then NZC >= the number of eigenvalues in (VL,VU].",
       "         If RANGE = 'I', then NZC >= IU-IL+1.",
       "         If NZC = -1, then a workspace query is assumed; the",
       "         routine calculates the number of columns of the array Z that",
       "         are needed to hold the eigenvectors.",
       "         This value is returned as the first entry of the Z array, and",
       "         no error message related to NZC is issued by XERBLA."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER ARRAY, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th computed eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is relevant in the case when the matrix",
       "         is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0."],
     "TRYRAC"=>
      ["[in,out]",
       "         TRYRAC is LOGICAL",
       "         If TRYRAC.EQ..TRUE., indicates that the code should check whether",
       "         the tridiagonal matrix defines its eigenvalues to high relative",
       "         accuracy.  If so, the code uses relative-accuracy preserving",
       "         algorithms that might be (a bit) slower depending on the matrix.",
       "         If the matrix does not define its eigenvalues to high relative",
       "         accuracy, the code can uses possibly faster algorithms.",
       "         If TRYRAC.EQ..FALSE., the code is not required to guarantee",
       "         relatively accurate eigenvalues and can use the fastest possible",
       "         techniques.",
       "         On exit, a .TRUE. TRYRAC will be set to .FALSE. if the matrix",
       "         does not define its eigenvalues to high relative accuracy."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal",
       "         (and minimal) LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,18*N)",
       "         if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (LIWORK)",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N)",
       "         if the eigenvectors are desired, and LIWORK >= max(1,8*N)",
       "         if only the eigenvalues are to be computed.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = 1X, internal error in DLARRE,",
       "               if INFO = 2X, internal error in ZLARRV.",
       "               Here, the digit X = ABS( IINFO ) < 10, where IINFO is",
       "               the nonzero error code returned by DLARRE or",
       "               ZLARRV, respectively."]}},
 "dlassq"=>
  {"summary"=>
    ["DLASSQ  returns the values  scl  and  smsq  such that",
     "   ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq,",
     "where  x( i ) = X( 1 + ( i - 1 )*INCX ). The value of  sumsq  is",
     "assumed to be non-negative and  scl  returns the value",
     "   scl = max( scale, abs( x( i ) ) ).",
     "scale and sumsq must be supplied in SCALE and SUMSQ and",
     "scl and smsq are overwritten on SCALE and SUMSQ respectively.",
     "The routine makes only one pass through the vector x."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements to be used from the vector X."],
     "X"=>
      ["[in]",
       "         X is DOUBLE PRECISION array, dimension (N)",
       "         The vector for which a scaled sum of squares is computed.",
       "            x( i )  = X( 1 + ( i - 1 )*INCX ), 1 <= i <= n."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of the vector X.",
       "         INCX > 0."],
     "SCALE"=>
      ["[in,out]",
       "         SCALE is DOUBLE PRECISION",
       "         On entry, the value  scale  in the equation above.",
       "         On exit, SCALE is overwritten with  scl , the scaling factor",
       "         for the sum of squares."],
     "SUMSQ"=>
      ["[in,out]",
       "         SUMSQ is DOUBLE PRECISION",
       "         On entry, the value  sumsq  in the equation above.",
       "         On exit, SUMSQ is overwritten with  smsq , the basic sum of",
       "         squares from which  scl  has been factored out."]}},
 "zuncsd2by1"=>
  {"summary"=>[],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is computed;",
       "         otherwise:  U1 is not computed."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is computed;",
       "         otherwise:  U2 is not computed."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is computed;",
       "         otherwise:  V1T is not computed."],
     "M"=>
      ["[in]", "         M is INTEGER", "         The number of rows in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX*16 array, dimension (LDX11,Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. LDX11 >= MAX(1,P)."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX*16 array, dimension (LDX21,Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "         The leading dimension of X21. LDX21 >= MAX(1,M-P)."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (R), in which R =",
       "         MIN(P,M-P,Q,M-Q).",
       "         C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and",
       "         S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) )."],
     "U1"=>
      ["[out]",
       "         U1 is COMPLEX*16 array, dimension (P)",
       "         If JOBU1 = 'Y', U1 contains the P-by-P unitary matrix U1."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of U1. If JOBU1 = 'Y', LDU1 >=",
       "         MAX(1,P)."],
     "U2"=>
      ["[out]",
       "         U2 is COMPLEX*16 array, dimension (M-P)",
       "         If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) unitary",
       "         matrix U2."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of U2. If JOBU2 = 'Y', LDU2 >=",
       "         MAX(1,M-P)."],
     "V1T"=>
      ["[out]",
       "         V1T is COMPLEX*16 array, dimension (Q)",
       "         If JOBV1T = 'Y', V1T contains the Q-by-Q matrix unitary",
       "         matrix V1**T."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >=",
       "         MAX(1,Q)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.",
       "         If INFO > 0 on exit, RWORK(2:R) contains the values PHI(1),",
       "         ..., PHI(R-1) that, together with THETA(1), ..., THETA(R),",
       "         define the matrix in intermediate bidiagonal-block form",
       "         remaining after nonconvergence. INFO specifies the number",
       "         of nonzero PHI's."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If LRWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the RWORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LRWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  ZBBCSD did not converge. See the description of WORK",
       "               above for details."]}},
 "ssysvxx"=>
  {"summary"=>
    ["   SSYSVXX uses the diagonal pivoting factorization to compute the",
     "   solution to a real system of linear equations A * X = B, where A",
     "   is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. SSYSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   SSYSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   SSYSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what SSYSVXX would itself produce."],
   "param"=>nil},
 "dhsein"=>
  {"summary"=>
    ["DHSEIN uses inverse iteration to find specified right and/or left",
     "eigenvectors of a real upper Hessenberg matrix H.",
     "The right eigenvector x and the left eigenvector y of the matrix H",
     "corresponding to an eigenvalue w are defined by:",
     "             H * x = w * x,     y**h * H = w * y**h",
     "where y**h denotes the conjugate transpose of the vector y."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R': compute right eigenvectors only;",
       "         = 'L': compute left eigenvectors only;",
       "         = 'B': compute both right and left eigenvectors."],
     "EIGSRC"=>
      ["[in]",
       "         EIGSRC is CHARACTER*1",
       "         Specifies the source of eigenvalues supplied in (WR,WI):",
       "         = 'Q': the eigenvalues were found using DHSEQR; thus, if",
       "                H has zero subdiagonal elements, and so is",
       "                block-triangular, then the j-th eigenvalue can be",
       "                assumed to be an eigenvalue of the block containing",
       "                the j-th row/column.  This property allows DHSEIN to",
       "                perform inverse iteration on just one diagonal block.",
       "         = 'N': no assumptions are made on the correspondence",
       "                between eigenvalues and diagonal blocks.  In this",
       "                case, DHSEIN must always perform inverse iteration",
       "                using the whole matrix H."],
     "INITV"=>
      ["[in]",
       "         INITV is CHARACTER*1",
       "         = 'N': no initial vectors are supplied;",
       "         = 'U': user-supplied initial vectors are stored in the arrays",
       "                VL and/or VR."],
     "SELECT"=>
      ["[in,out]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         Specifies the eigenvectors to be computed. To select the",
       "         real eigenvector corresponding to a real eigenvalue WR(j),",
       "         SELECT(j) must be set to .TRUE.. To select the complex",
       "         eigenvector corresponding to a complex eigenvalue",
       "         (WR(j),WI(j)), with complex conjugate (WR(j+1),WI(j+1)),",
       "         either SELECT(j) or SELECT(j+1) or both must be set to",
       "         .TRUE.; then on exit SELECT(j) is .TRUE. and SELECT(j+1) is",
       "         .FALSE.."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "H"=>
      ["[in]",
       "         H is DOUBLE PRECISION array, dimension (LDH,N)",
       "         The upper Hessenberg matrix H.",
       "         If a NaN is detected in H, the routine will return with INFO=-6."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max(1,N)."],
     "WR"=>
      ["[in,out]", "         WR is DOUBLE PRECISION array, dimension (N)"],
     "WI"=>
      ["[in]",
       "         WI is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the real and imaginary parts of the eigenvalues of",
       "         H; a complex conjugate pair of eigenvalues must be stored in",
       "         consecutive elements of WR and WI.",
       "         On exit, WR may have been altered since close eigenvalues",
       "         are perturbed slightly in searching for independent",
       "         eigenvectors."],
     "VL"=>
      ["[in,out]",
       "         VL is DOUBLE PRECISION array, dimension (LDVL,MM)",
       "         On entry, if INITV = 'U' and SIDE = 'L' or 'B', VL must",
       "         contain starting vectors for the inverse iteration for the",
       "         left eigenvectors; the starting vector for each eigenvector",
       "         must be in the same column(s) in which the eigenvector will",
       "         be stored.",
       "         On exit, if SIDE = 'L' or 'B', the left eigenvectors",
       "         specified by SELECT will be stored consecutively in the",
       "         columns of VL, in the same order as their eigenvalues. A",
       "         complex eigenvector corresponding to a complex eigenvalue is",
       "         stored in two consecutive columns, the first holding the real",
       "         part and the second the imaginary part.",
       "         If SIDE = 'R', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= max(1,N) if SIDE = 'L' or 'B'; LDVL >= 1 otherwise."],
     "VR"=>
      ["[in,out]",
       "         VR is DOUBLE PRECISION array, dimension (LDVR,MM)",
       "         On entry, if INITV = 'U' and SIDE = 'R' or 'B', VR must",
       "         contain starting vectors for the inverse iteration for the",
       "         right eigenvectors; the starting vector for each eigenvector",
       "         must be in the same column(s) in which the eigenvector will",
       "         be stored.",
       "         On exit, if SIDE = 'R' or 'B', the right eigenvectors",
       "         specified by SELECT will be stored consecutively in the",
       "         columns of VR, in the same order as their eigenvalues. A",
       "         complex eigenvector corresponding to a complex eigenvalue is",
       "         stored in two consecutive columns, the first holding the real",
       "         part and the second the imaginary part.",
       "         If SIDE = 'L', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= max(1,N) if SIDE = 'R' or 'B'; LDVR >= 1 otherwise."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR required to",
       "         store the eigenvectors; each selected real eigenvector",
       "         occupies one column and each selected complex eigenvector",
       "         occupies two columns."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension ((N+2)*N)"],
     "IFAILL"=>
      ["[out]",
       "         IFAILL is INTEGER array, dimension (MM)",
       "         If SIDE = 'L' or 'B', IFAILL(i) = j > 0 if the left",
       "         eigenvector in the i-th column of VL (corresponding to the",
       "         eigenvalue w(j)) failed to converge; IFAILL(i) = 0 if the",
       "         eigenvector converged satisfactorily. If the i-th and (i+1)th",
       "         columns of VL hold a complex eigenvector, then IFAILL(i) and",
       "         IFAILL(i+1) are set to the same value.",
       "         If SIDE = 'R', IFAILL is not referenced."],
     "IFAILR"=>
      ["[out]",
       "         IFAILR is INTEGER array, dimension (MM)",
       "         If SIDE = 'R' or 'B', IFAILR(i) = j > 0 if the right",
       "         eigenvector in the i-th column of VR (corresponding to the",
       "         eigenvalue w(j)) failed to converge; IFAILR(i) = 0 if the",
       "         eigenvector converged satisfactorily. If the i-th and (i+1)th",
       "         columns of VR hold a complex eigenvector, then IFAILR(i) and",
       "         IFAILR(i+1) are set to the same value.",
       "         If SIDE = 'L', IFAILR is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, i is the number of eigenvectors which",
       "               failed to converge; see IFAILL and IFAILR for further",
       "               details."]}},
 "sla_syamv"=>
  {"summary"=>
    ["SLA_SYAMV  performs the matrix-vector operation",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "n by n symmetric matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is INTEGER",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array A is to be referenced as",
       "          follows:",
       "             UPLO = BLAS_UPPER   Only the upper triangular part of A",
       "                                 is to be referenced.",
       "             UPLO = BLAS_LOWER   Only the lower triangular part of A",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL .",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is REAL array of DIMENSION ( LDA, n ).",
       "          Before entry, the leading m by n part of the array A must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, n ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is REAL array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCX ) )",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL .",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCY ) )",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit."]}},
 "dgebd2"=>
  {"summary"=>
    ["DGEBD2 reduces a real general m by n matrix A to upper or lower",
     "bidiagonal form B by an orthogonal transformation: Q**T * A * P = B.",
     "If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the m by n general matrix to be reduced.",
       "         On exit,",
       "         if m >= n, the diagonal and the first superdiagonal are",
       "           overwritten with the upper bidiagonal matrix B; the",
       "           elements below the diagonal, with the array TAUQ, represent",
       "           the orthogonal matrix Q as a product of elementary",
       "           reflectors, and the elements above the first superdiagonal,",
       "           with the array TAUP, represent the orthogonal matrix P as",
       "           a product of elementary reflectors;",
       "         if m < n, the diagonal and the first subdiagonal are",
       "           overwritten with the lower bidiagonal matrix B; the",
       "           elements below the first subdiagonal, with the array TAUQ,",
       "           represent the orthogonal matrix Q as a product of",
       "           elementary reflectors, and the elements above the diagonal,",
       "           with the array TAUP, represent the orthogonal matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (min(M,N)-1)",
       "         The off-diagonal elements of the bidiagonal matrix B:",
       "         if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;",
       "         if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is DOUBLE PRECISION array dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix P. See Further Details."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (max(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit.",
       "         < 0: if INFO = -i, the i-th argument had an illegal value."]}},
 "sgeevx"=>
  {"summary"=>
    ["SGEEVX computes for an N-by-N real nonsymmetric matrix A, the",
     "eigenvalues and, optionally, the left and/or right eigenvectors.",
     "Optionally also, it computes a balancing transformation to improve",
     "the conditioning of the eigenvalues and eigenvectors (ILO, IHI,",
     "SCALE, and ABNRM), reciprocal condition numbers for the eigenvalues",
     "(RCONDE), and reciprocal condition numbers for the right",
     "eigenvectors (RCONDV).",
     "The right eigenvector v(j) of A satisfies",
     "                 A * v(j) = lambda(j) * v(j)",
     "where lambda(j) is its eigenvalue.",
     "The left eigenvector u(j) of A satisfies",
     "              u(j)**H * A = lambda(j) * u(j)**H",
     "where u(j)**H denotes the conjugate-transpose of u(j).",
     "The computed eigenvectors are normalized to have Euclidean norm",
     "equal to 1 and largest component real.",
     "Balancing a matrix means permuting the rows and columns to make it",
     "more nearly upper triangular, and applying a diagonal similarity",
     "transformation D * A * D**(-1), where D is a diagonal matrix, to",
     "make its rows and columns closer in norm and the condition numbers",
     "of its eigenvalues and eigenvectors smaller.  The computed",
     "reciprocal condition numbers correspond to the balanced matrix.",
     "Permuting rows and columns will not change the condition numbers",
     "(in exact arithmetic) but diagonal scaling will.  For further",
     "explanation of balancing, see section 4.10.2 of the LAPACK",
     "Users' Guide."],
   "param"=>
    {"BALANC"=>
      ["[in]",
       "         BALANC is CHARACTER*1",
       "         Indicates how the input matrix should be diagonally scaled",
       "         and/or permuted to improve the conditioning of its",
       "         eigenvalues.",
       "         = 'N': Do not diagonally scale or permute;",
       "         = 'P': Perform permutations to make the matrix more nearly",
       "                upper triangular. Do not diagonally scale;",
       "         = 'S': Diagonally scale the matrix, i.e. replace A by",
       "                D*A*D**(-1), where D is a diagonal matrix chosen",
       "                to make the rows and columns of A more equal in",
       "                norm. Do not permute;",
       "         = 'B': Both diagonally scale and permute A.",
       "         Computed reciprocal condition numbers will be for the matrix",
       "         after balancing and/or permuting. Permuting does not change",
       "         condition numbers (in exact arithmetic), but balancing does."],
     "JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N': left eigenvectors of A are not computed;",
       "         = 'V': left eigenvectors of A are computed.",
       "         If SENSE = 'E' or 'B', JOBVL must = 'V'."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N': right eigenvectors of A are not computed;",
       "         = 'V': right eigenvectors of A are computed.",
       "         If SENSE = 'E' or 'B', JOBVR must = 'V'."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': None are computed;",
       "         = 'E': Computed for eigenvalues only;",
       "         = 'V': Computed for right eigenvectors only;",
       "         = 'B': Computed for eigenvalues and right eigenvectors.",
       "         If SENSE = 'E' or 'B', both left and right eigenvectors",
       "         must also be computed (JOBVL = 'V' and JOBVR = 'V')."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten.  If JOBVL = 'V' or",
       "         JOBVR = 'V', A contains the real Schur form of the balanced",
       "         version of the input matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "WR"=>["[out]", "         WR is REAL array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is REAL array, dimension (N)",
       "         WR and WI contain the real and imaginary parts,",
       "         respectively, of the computed eigenvalues.  Complex",
       "         conjugate pairs of eigenvalues will appear consecutively",
       "         with the eigenvalue having the positive imaginary part",
       "         first."],
     "VL"=>
      ["[out]",
       "         VL is REAL array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order",
       "         as their eigenvalues.",
       "         If JOBVL = 'N', VL is not referenced.",
       "         If the j-th eigenvalue is real, then u(j) = VL(:,j),",
       "         the j-th column of VL.",
       "         If the j-th and (j+1)-st eigenvalues form a complex",
       "         conjugate pair, then u(j) = VL(:,j) + i*VL(:,j+1) and",
       "         u(j+1) = VL(:,j) - i*VL(:,j+1)."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1; if",
       "         JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is REAL array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order",
       "         as their eigenvalues.",
       "         If JOBVR = 'N', VR is not referenced.",
       "         If the j-th eigenvalue is real, then v(j) = VR(:,j),",
       "         the j-th column of VR.",
       "         If the j-th and (j+1)-st eigenvalues form a complex",
       "         conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and",
       "         v(j+1) = VR(:,j) - i*VR(:,j+1)."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1, and if",
       "         JOBVR = 'V', LDVR >= N."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are integer values determined when A was",
       "         balanced.  The balanced A(i,j) = 0 if I > J and",
       "         J = 1,...,ILO-1 or I = IHI+1,...,N."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         when balancing A.  If P(j) is the index of the row and column",
       "         interchanged with row and column j, and D(j) is the scaling",
       "         factor applied to row and column j, then",
       "         SCALE(J) = P(J),    for J = 1,...,ILO-1",
       "                  = D(J),    for J = ILO,...,IHI",
       "                  = P(J)     for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "ABNRM"=>
      ["[out]",
       "         ABNRM is REAL",
       "         The one-norm of the balanced matrix (the maximum",
       "         of the sum of absolute values of elements of any column)."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is REAL array, dimension (N)",
       "         RCONDE(j) is the reciprocal condition number of the j-th",
       "         eigenvalue."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is REAL array, dimension (N)",
       "         RCONDV(j) is the reciprocal condition number of the j-th",
       "         right eigenvector."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.   If SENSE = 'N' or 'E',",
       "         LWORK >= max(1,2*N), and if JOBVL = 'V' or JOBVR = 'V',",
       "         LWORK >= 3*N.  If SENSE = 'V' or 'B', LWORK >= N*(N+6).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (2*N-2)",
       "         If SENSE = 'N' or 'E', not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the QR algorithm failed to compute all the",
       "               eigenvalues, and no eigenvectors or condition numbers",
       "               have been computed; elements 1:ILO-1 and i+1:N of WR",
       "               and WI contain eigenvalues which have converged."]}},
 "dlantr"=>
  {"summary"=>
    ["DLANTR  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "trapezoidal or triangular matrix A.",
     "   DLANTR = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANTR as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower trapezoidal.",
       "         = 'U':  Upper trapezoidal",
       "         = 'L':  Lower trapezoidal",
       "         Note that A is triangular instead of trapezoidal if M = N."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A has unit diagonal.",
       "         = 'N':  Non-unit diagonal",
       "         = 'U':  Unit diagonal"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0, and if",
       "         UPLO = 'U', M <= N.  When M = 0, DLANTR is set to zero."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0, and if",
       "         UPLO = 'L', N <= M.  When N = 0, DLANTR is set to zero."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The trapezoidal matrix A (A is triangular if M = N).",
       "         If UPLO = 'U', the leading m by n upper trapezoidal part of",
       "         the array A contains the upper trapezoidal matrix, and the",
       "         strictly lower triangular part of A is not referenced.",
       "         If UPLO = 'L', the leading m by n lower trapezoidal part of",
       "         the array A contains the lower trapezoidal matrix, and the",
       "         strictly upper triangular part of A is not referenced.  Note",
       "         that when DIAG = 'U', the diagonal elements of A are not",
       "         referenced and are assumed to be one."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= M when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "ssygv"=>
  {"summary"=>
    ["SSYGV computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be symmetric and B is also",
     "positive definite."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, the symmetric positive definite matrix B.",
       "         If UPLO = 'U', the leading N-by-N upper triangular part of B",
       "         contains the upper triangular part of the matrix B.",
       "         If UPLO = 'L', the leading N-by-N lower triangular part of B",
       "         contains the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,3*N-1).",
       "         For optimal efficiency, LWORK >= (NB+2)*N,",
       "         where NB is the blocksize for SSYTRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  SPOTRF or SSYEV returned an error code:",
       "            <= N:  if INFO = i, SSYEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "stfsm"=>
  {"summary"=>
    ["Level 3 BLAS like routine for A in RFP Format.",
     "STFSM  solves the matrix equation",
     "   op( A )*X = alpha*B  or  X*op( A ) = alpha*B",
     "where alpha is a scalar, X and B are m by n matrices, A is a unit, or",
     "non-unit,  upper or lower triangular matrix  and  op( A )  is one  of",
     "   op( A ) = A   or   op( A ) = A**T.",
     "A is in Rectangular Full Packed (RFP) Format.",
     "The matrix X is overwritten on B."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal Form of RFP A is stored;",
       "         = 'T':  The Transpose Form of RFP A is stored."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "          On entry, SIDE specifies whether op( A ) appears on the left",
       "          or right of X as follows:",
       "             SIDE = 'L' or 'l'   op( A )*X = alpha*B.",
       "             SIDE = 'R' or 'r'   X*op( A ) = alpha*B.",
       "          Unchanged on exit."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the RFP matrix A came from",
       "          an upper or lower triangular matrix as follows:",
       "          UPLO = 'U' or 'u' RFP A came from an upper triangular matrix",
       "          UPLO = 'L' or 'l' RFP A came from a  lower triangular matrix",
       "          Unchanged on exit."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "          On entry, TRANS  specifies the form of op( A ) to be used",
       "          in the matrix multiplication as follows:",
       "             TRANS  = 'N' or 'n'   op( A ) = A.",
       "             TRANS  = 'T' or 't'   op( A ) = A'.",
       "          Unchanged on exit."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "          On entry, DIAG specifies whether or not RFP A is unit",
       "          triangular as follows:",
       "             DIAG = 'U' or 'u'   A is assumed to be unit triangular.",
       "             DIAG = 'N' or 'n'   A is not assumed to be unit",
       "                                 triangular.",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of B. M must be at",
       "          least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of B.  N must be",
       "          at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "          On entry,  ALPHA specifies the scalar  alpha. When  alpha is",
       "          zero then  A is not referenced and  B need not be set before",
       "          entry.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (NT)",
       "          NT = N*(N+1)/2. On entry, the matrix A in RFP Format.",
       "          RFP Format is described by TRANSR, UPLO and N as follows:",
       "          If TRANSR='N' then RFP A is (0:N,0:K-1) when N is even;",
       "          K=N/2. RFP A is (0:N-1,0:K) when N is odd; K=N/2. If",
       "          TRANSR = 'T' then RFP is the transpose of RFP A as",
       "          defined when TRANSR = 'N'. The contents of RFP A are defined",
       "          by UPLO as follows: If UPLO = 'U' the RFP A contains the NT",
       "          elements of upper packed A either in normal or",
       "          transpose Format. If UPLO = 'L' the RFP A contains",
       "          the NT elements of lower packed A either in normal or",
       "          transpose Format. The LDA of RFP A is (N+1)/2 when",
       "          TRANSR = 'T'. When TRANSR is 'N' the LDA is N+1 when N is",
       "          even and is N when is odd.",
       "          See the Note below for more details. Unchanged on exit."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, DIMENSION (LDB,N)",
       "          Before entry,  the leading  m by n part of the array  B must",
       "          contain  the  right-hand  side  matrix  B,  and  on exit  is",
       "          overwritten by the solution matrix  X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "          On entry, LDB specifies the first dimension of B as declared",
       "          in  the  calling  (sub)  program.   LDB  must  be  at  least",
       "          max( 1, m ).",
       "          Unchanged on exit."]}},
 "dsbgst"=>
  {"summary"=>
    ["DSBGST reduces a real symmetric-definite banded generalized",
     "eigenproblem  A*x = lambda*B*x  to standard form  C*y = lambda*y,",
     "such that C has the same bandwidth as A.",
     "B must have been previously factorized as S**T*S by DPBSTF, using a",
     "split Cholesky factorization. A is overwritten by C = X**T*A*X, where",
     "X = S**(-1)*Q and Q is an orthogonal matrix chosen to preserve the",
     "bandwidth of A."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  do not form the transformation matrix X;",
       "         = 'V':  form X."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the transformed matrix X**T*A*X, stored in the same",
       "         format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in]",
       "         BB is DOUBLE PRECISION array, dimension (LDBB,N)",
       "         The banded factor S from the split Cholesky factorization of",
       "         B, as returned by DPBSTF, stored in the first KB+1 rows of",
       "         the array."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "X"=>
      ["[out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,N)",
       "         If VECT = 'V', the n-by-n matrix X.",
       "         If VECT = 'N', the array X is not referenced."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.",
       "         LDX >= max(1,N) if VECT = 'V'; LDX >= 1 otherwise."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "cunmtr"=>
  {"summary"=>
    ["CUNMTR overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "nq-1 elementary reflectors, as returned by CHETRD:",
     "if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangle of A contains elementary reflectors",
       "                from CHETRD;",
       "         = 'L': Lower triangle of A contains elementary reflectors",
       "                from CHETRD."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension",
       "                              (LDA,M) if SIDE = 'L'",
       "                              (LDA,N) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by CHETRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension",
       "                              (M-1) if SIDE = 'L'",
       "                              (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CHETRD."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For optimum performance LWORK >= N*NB if SIDE = 'L', and",
       "         LWORK >=M*NB if SIDE = 'R', where NB is the optimal",
       "         blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlanst"=>
  {"summary"=>
    ["DLANST  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "real symmetric tridiagonal matrix A.",
     "   DLANST = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANST as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, DLANST is",
       "         set to zero."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of A."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) sub-diagonal or super-diagonal elements of A."]}},
 "csyconvf"=>
  {"summary"=>
    ["If parameter WAY = 'C':",
     "CSYCONVF converts the factorization output format used in",
     "CSYTRF provided on entry in parameter A into the factorization",
     "output format used in CSYTRF_RK (or CSYTRF_BK) that is stored",
     "on exit in parameters A and E. It also coverts in place details of",
     "the intechanges stored in IPIV from the format used in CSYTRF into",
     "the format used in CSYTRF_RK (or CSYTRF_BK).",
     "If parameter WAY = 'R':",
     "CSYCONVF performs the conversion in reverse direction, i.e.",
     "converts the factorization output format used in CSYTRF_RK",
     "(or CSYTRF_BK) provided on entry in parametes A and E into",
     "the factorization output format used in CSYTRF that is stored",
     "on exit in parameter A. It also coverts in place details of",
     "the intechanges stored in IPIV from the format used in CSYTRF_RK",
     "(or CSYTRF_BK) into the format used in CSYTRF.",
     "CSYCONVF can also convert in Hermitian matrix case, i.e. between",
     "formats used in CHETRF and CHETRF_RK (or CHETRF_BK)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix A.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         1) If WAY ='C':",
       "         On entry, contains factorization details in format used in",
       "         CSYTRF:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         CSYTRF_RK or CSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         2) If WAY = 'R':",
       "         On entry, contains factorization details in format used in",
       "         CSYTRF_RK or CSYTRF_BK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, contains factorization details in format used in",
       "         CSYTRF:",
       "           a) all elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A and on superdiagonal",
       "              (or subdiagonal) of A, and",
       "           b) If UPLO = 'U': multipliers used to obtain factor U",
       "              in the superdiagonal part of A.",
       "              If UPLO = 'L': multipliers used to obtain factor L",
       "              in the superdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in,out]",
       "         E is COMPLEX array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, just a workspace.",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         2) If WAY = 'R':",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not referenced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         On exit, is not changed"],
     "IPIV"=>
      ["[in,out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         1) If WAY ='C':",
       "         On entry, details of the interchanges and the block",
       "         structure of D in the format used in CSYTRF.",
       "         On exit, details of the interchanges and the block",
       "         structure of D in the format used in CSYTRF_RK",
       "         ( or CSYTRF_BK).",
       "         1) If WAY ='R':",
       "         On entry, details of the interchanges and the block",
       "         structure of D in the format used in CSYTRF_RK",
       "         ( or CSYTRF_BK).",
       "         On exit, details of the interchanges and the block",
       "         structure of D in the format used in CSYTRF."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhetrf_rook"=>
  {"summary"=>
    ["ZHETRF_ROOK computes the factorization of a complex Hermitian matrix A",
     "using the bounded Bunch-Kaufman (\"rook\") diagonal pivoting method.",
     "The form of the factorization is",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is Hermitian and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k-1 and -IPIV(k-1) were inerchaged,",
       "            D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k)",
       "            were interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and",
       "            columns k and -IPIV(k) were interchanged and rows and",
       "            columns k+1 and -IPIV(k+1) were inerchaged,",
       "            D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "clarcm"=>
  {"summary"=>
    ["CLARCM performs a very simple matrix-matrix multiplication:",
     "         C := A * B,",
     "where A is M by M and real; B is M by N and complex;",
     "C is M by N and complex."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A and of the matrix C.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns and rows of the matrix B and",
       "         the number of columns of the matrix C.",
       "         N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA, M)",
       "         On entry, A contains the M by M matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >=max(1,M)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, B contains the M by N matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >=max(1,M)."],
     "C"=>
      ["[out]",
       "         C is COMPLEX array, dimension (LDC, N)",
       "         On exit, C contains the M by N matrix C."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >=max(1,M)."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*M*N)"]}},
 "sorg2l"=>
  {"summary"=>
    ["SORG2L generates an m by n real matrix Q with orthonormal columns,",
     "which is defined as the last n columns of a product of k elementary",
     "reflectors of order m",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by SGEQLF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the (n-k+i)-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by SGEQLF in the last k columns of its array",
       "         argument A.",
       "         On exit, the m by n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGEQLF."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "clarscl2"=>
  {"summary"=>
    ["CLARSCL2 performs a reciprocal diagonal scaling on an vector:",
     "  x <-- inv(D) * x",
     "where the REAL diagonal matrix D is stored as a vector.",
     "Eventually to be replaced by BLAS_cge_diag_scale in the new BLAS",
     "standard."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "    The number of rows of D and X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of columns of X. N >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, length M",
       "    Diagonal matrix D, stored as a vector of length M."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,N)",
       "    On entry, the vector X to be scaled by D.",
       "    On exit, the scaled vector."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the vector X. LDX >= M."]}},
 "zsytri"=>
  {"summary"=>
    ["ZSYTRI computes the inverse of a complex symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "ZSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by ZSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "zhegv"=>
  {"summary"=>
    ["ZHEGV computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be Hermitian and B is also",
     "positive definite."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the Hermitian positive definite matrix B.",
       "         If UPLO = 'U', the leading N-by-N upper triangular part of B",
       "         contains the upper triangular part of the matrix B.",
       "         If UPLO = 'L', the leading N-by-N lower triangular part of B",
       "         contains the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,2*N-1).",
       "         For optimal efficiency, LWORK >= (NB+1)*N,",
       "         where NB is the blocksize for ZHETRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  ZPOTRF or ZHEEV returned an error code:",
       "            <= N:  if INFO = i, ZHEEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "sgbtrs"=>
  {"summary"=>
    ["SGBTRS solves a system of linear equations",
     "   A * X = B  or  A**T * X = B",
     "with a general band matrix A using the LU factorization computed",
     "by SGBTRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations.",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T* X = B  (Transpose)",
       "         = 'C':  A**T* X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by SGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= N, row i of the matrix was",
       "         interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dtrsna"=>
  {"summary"=>
    ["DTRSNA estimates reciprocal condition numbers for specified",
     "eigenvalues and/or right eigenvectors of a real upper",
     "quasi-triangular matrix T (or of any matrix Q*T*Q**T with Q",
     "orthogonal).",
     "T must be in Schur canonical form (as returned by DHSEQR), that is,",
     "block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each",
     "2-by-2 diagonal block has its diagonal elements equal and its",
     "off-diagonal elements of opposite sign."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for",
       "         eigenvalues (S) or eigenvectors (SEP):",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for eigenvectors only (SEP);",
       "         = 'B': for both eigenvalues and eigenvectors (S and SEP)."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute condition numbers for all eigenpairs;",
       "         = 'S': compute condition numbers for selected eigenpairs",
       "                specified by the array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenpairs for which",
       "         condition numbers are required. To select condition numbers",
       "         for the eigenpair corresponding to a real eigenvalue w(j),",
       "         SELECT(j) must be set to .TRUE.. To select condition numbers",
       "         corresponding to a complex conjugate pair of eigenvalues w(j)",
       "         and w(j+1), either SELECT(j) or SELECT(j+1) or both, must be",
       "         set to .TRUE..",
       "         If HOWMNY = 'A', SELECT is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         The upper quasi-triangular matrix T, in Schur canonical form."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION array, dimension (LDVL,M)",
       "         If JOB = 'E' or 'B', VL must contain left eigenvectors of T",
       "         (or of any Q*T*Q**T with Q orthogonal), corresponding to the",
       "         eigenpairs specified by HOWMNY and SELECT. The eigenvectors",
       "         must be stored in consecutive columns of VL, as returned by",
       "         DHSEIN or DTREVC.",
       "         If JOB = 'V', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= 1; and if JOB = 'E' or 'B', LDVL >= N."],
     "VR"=>
      ["[in]",
       "         VR is DOUBLE PRECISION array, dimension (LDVR,M)",
       "         If JOB = 'E' or 'B', VR must contain right eigenvectors of T",
       "         (or of any Q*T*Q**T with Q orthogonal), corresponding to the",
       "         eigenpairs specified by HOWMNY and SELECT. The eigenvectors",
       "         must be stored in consecutive columns of VR, as returned by",
       "         DHSEIN or DTREVC.",
       "         If JOB = 'V', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= 1; and if JOB = 'E' or 'B', LDVR >= N."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (MM)",
       "         If JOB = 'E' or 'B', the reciprocal condition numbers of the",
       "         selected eigenvalues, stored in consecutive elements of the",
       "         array. For a complex conjugate pair of eigenvalues two",
       "         consecutive elements of S are set to the same value. Thus",
       "         S(j), SEP(j), and the j-th columns of VL and VR all",
       "         correspond to the same eigenpair (but not in general the",
       "         j-th eigenpair, unless all eigenpairs are selected).",
       "         If JOB = 'V', S is not referenced."],
     "SEP"=>
      ["[out]",
       "         SEP is DOUBLE PRECISION array, dimension (MM)",
       "         If JOB = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the selected eigenvectors, stored in consecutive",
       "         elements of the array. For a complex eigenvector two",
       "         consecutive elements of SEP are set to the same value. If",
       "         the eigenvalues cannot be reordered to compute SEP(j), SEP(j)",
       "         is set to 0; this can only occur when the true value would be",
       "         very small anyway.",
       "         If JOB = 'E', SEP is not referenced."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of elements in the arrays S (if JOB = 'E' or 'B')",
       "          and/or SEP (if JOB = 'V' or 'B'). MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of elements of the arrays S and/or SEP actually",
       "         used to store the estimated condition numbers.",
       "         If HOWMNY = 'A', M is set to N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LDWORK,N+6)",
       "         If JOB = 'E', WORK is not referenced."],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         LDWORK >= 1; and if JOB = 'V' or 'B', LDWORK >= N."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (2*(N-1))",
       "         If JOB = 'E', IWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dposvxx"=>
  {"summary"=>
    ["   DPOSVXX uses the Cholesky factorization A = U**T*U or A = L*L**T",
     "   to compute the solution to a double precision system of linear equations",
     "   A * X = B, where A is an N-by-N symmetric positive definite matrix",
     "   and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. DPOSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   DPOSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   DPOSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what DPOSVXX would itself produce."],
   "param"=>nil},
 "ssbev"=>
  {"summary"=>
    ["SSBEV computes all the eigenvalues and, optionally, eigenvectors of",
     "a real symmetric band matrix A."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is REAL array, dimension (max(1,3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dgemlqt"=>
  {"summary"=>
    ["DGEMQRT overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q C            C Q",
     "TRANS = 'T':   Q**T C            C Q**T",
     "where Q is a real orthogonal matrix defined as the product of K",
     "elementary reflectors:",
     "      Q = H(1) H(2) . . . H(K) = I - V T V**T",
     "generated using the compact WY representation as returned by DGELQT.",
     "Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size used for the storage of T.  K >= MB >= 1.",
       "         This must be the same value of MB used to generate T",
       "         in DGELQT."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension (LDV,K)",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGELQT in the first K rows of its array argument A."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (LDT,K)",
       "         The upper triangular factors of the block reflectors",
       "         as returned by DGELQT, stored as a MB-by-M matrix."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q C, Q**T C, C Q**T or C Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array. The dimension of",
       "         WORK is N*MB if SIDE = 'L', or  M*MB if SIDE = 'R'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zgges3"=>
  {"summary"=>
    ["ZGGES3 computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, the generalized complex Schur",
     "form (S, T), and optionally left and/or right Schur vectors (VSL",
     "and VSR). This gives the generalized Schur factorization",
     "        (A,B) = ( (VSL)*S*(VSR)**H, (VSL)*T*(VSR)**H )",
     "where (VSR)**H is the conjugate-transpose of VSR.",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "triangular matrix S and the upper triangular matrix T. The leading",
     "columns of VSL and VSR then form an unitary basis for the",
     "corresponding left and right eigenspaces (deflating subspaces).",
     "(If only the generalized eigenvalues are needed, use the driver",
     "ZGGEV instead, which is faster.)",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0, and even for both being zero.",
     "A pair of matrices (S,T) is in generalized complex Schur form if S",
     "and T are upper triangular and, in addition, the diagonal elements",
     "of T are non-negative real numbers."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG)."],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is a LOGICAL FUNCTION of two COMPLEX*16 arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         An eigenvalue ALPHA(j)/BETA(j) is selected if",
       "         SELCTG(ALPHA(j),BETA(j)) is true.",
       "         Note that a selected complex eigenvalue may no longer satisfy",
       "         SELCTG(ALPHA(j),BETA(j)) = .TRUE. after ordering, since",
       "         ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned), in this",
       "         case INFO is set to N+2 (See INFO below)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX*16 array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX*16 array, dimension (N)",
       "         On exit,  ALPHA(j)/BETA(j), j=1,...,N, will be the",
       "         generalized eigenvalues.  ALPHA(j), j=1,...,N  and  BETA(j),",
       "         j=1,...,N  are the diagonals of the complex Schur form (A,B)",
       "         output by ZGGES3. The  BETA(j) will be non-negative real.",
       "         Note: the quotients ALPHA(j)/BETA(j) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio alpha/beta.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is COMPLEX*16 array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >= 1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is COMPLEX*16 array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (8*N)"],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         =1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHA(j) and BETA(j) should be correct for",
       "               j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in ZHGEQZ",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in ZTGSEN."]}},
 "dgeesx"=>
  {"summary"=>
    ["DGEESX computes for an N-by-N real nonsymmetric matrix A, the",
     "eigenvalues, the real Schur form T, and, optionally, the matrix of",
     "Schur vectors Z.  This gives the Schur factorization A = Z*T*(Z**T).",
     "Optionally, it also orders the eigenvalues on the diagonal of the",
     "real Schur form so that selected eigenvalues are at the top left;",
     "computes a reciprocal condition number for the average of the",
     "selected eigenvalues (RCONDE); and computes a reciprocal condition",
     "number for the right invariant subspace corresponding to the",
     "selected eigenvalues (RCONDV).  The leading columns of Z form an",
     "orthonormal basis for this invariant subspace.",
     "For further explanation of the reciprocal condition numbers RCONDE",
     "and RCONDV, see Section 4.10 of the LAPACK Users' Guide (where",
     "these quantities are called s and sep respectively).",
     "A real matrix is in real Schur form if it is upper quasi-triangular",
     "with 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in",
     "the form",
     "          [  a  b  ]",
     "          [  c  a  ]",
     "where b*c < 0. The eigenvalues of such a block are a +- sqrt(bc)."],
   "param"=>
    {"JOBVS"=>
      ["[in]",
       "         JOBVS is CHARACTER*1",
       "         = 'N': Schur vectors are not computed;",
       "         = 'V': Schur vectors are computed."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the Schur form.",
       "         = 'N': Eigenvalues are not ordered;",
       "         = 'S': Eigenvalues are ordered (see SELECT)."],
     "SELECT"=>
      ["[in]",
       "         SELECT is a LOGICAL FUNCTION of two DOUBLE PRECISION arguments",
       "         SELECT must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'S', SELECT is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         If SORT = 'N', SELECT is not referenced.",
       "         An eigenvalue WR(j)+sqrt(-1)*WI(j) is selected if",
       "         SELECT(WR(j),WI(j)) is true; i.e., if either one of a",
       "         complex conjugate pair of eigenvalues is selected, then both",
       "         are.  Note that a selected complex eigenvalue may no longer",
       "         satisfy SELECT(WR(j),WI(j)) = .TRUE. after ordering, since",
       "         ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned); in this",
       "         case INFO may be set to N+3 (see INFO below)."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': None are computed;",
       "         = 'E': Computed for average of selected eigenvalues only;",
       "         = 'V': Computed for selected right invariant subspace only;",
       "         = 'B': Computed for both.",
       "         If SENSE = 'E', 'V' or 'B', SORT must equal 'S'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A is overwritten by its real Schur form T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "                        for which SELECT is true. (Complex conjugate",
       "                        pairs for which SELECT is true for either",
       "                        eigenvalue count as 2.)"],
     "WR"=>["[out]", "         WR is DOUBLE PRECISION array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is DOUBLE PRECISION array, dimension (N)",
       "         WR and WI contain the real and imaginary parts, respectively,",
       "         of the computed eigenvalues, in the same order that they",
       "         appear on the diagonal of the output Schur form T.  Complex",
       "         conjugate pairs of eigenvalues appear consecutively with the",
       "         eigenvalue having the positive imaginary part first."],
     "VS"=>
      ["[out]",
       "         VS is DOUBLE PRECISION array, dimension (LDVS,N)",
       "         If JOBVS = 'V', VS contains the orthogonal matrix Z of Schur",
       "         vectors.",
       "         If JOBVS = 'N', VS is not referenced."],
     "LDVS"=>
      ["[in]",
       "         LDVS is INTEGER",
       "         The leading dimension of the array VS.  LDVS >= 1, and if",
       "         JOBVS = 'V', LDVS >= N."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is DOUBLE PRECISION",
       "         If SENSE = 'E' or 'B', RCONDE contains the reciprocal",
       "         condition number for the average of the selected eigenvalues.",
       "         Not referenced if SENSE = 'N' or 'V'."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is DOUBLE PRECISION",
       "         If SENSE = 'V' or 'B', RCONDV contains the reciprocal",
       "         condition number for the selected right invariant subspace.",
       "         Not referenced if SENSE = 'N' or 'E'."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,3*N).",
       "         Also, if SENSE = 'E' or 'V' or 'B',",
       "         LWORK >= N+2*SDIM*(N-SDIM), where SDIM is the number of",
       "         selected eigenvalues computed by this routine.  Note that",
       "         N+2*SDIM*(N-SDIM) <= N+N*N/2. Note also that an error is only",
       "         returned if LWORK < max(1,3*N), but if SENSE = 'E' or 'V' or",
       "         'B' this may not be large enough.",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates upper bounds on the optimal sizes of the",
       "         arrays WORK and IWORK, returns these values as the first",
       "         entries of the WORK and IWORK arrays, and no error messages",
       "         related to LWORK or LIWORK are issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         LIWORK >= 1; if SENSE = 'V' or 'B', LIWORK >= SDIM*(N-SDIM).",
       "         Note that SDIM*(N-SDIM) <= N*N/4. Note also that an error is",
       "         only returned if LIWORK < 1, but if SENSE = 'V' or 'B' this",
       "         may not be large enough.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates upper bounds on the optimal sizes of",
       "         the arrays WORK and IWORK, returns these values as the first",
       "         entries of the WORK and IWORK arrays, and no error messages",
       "         related to LWORK or LIWORK are issued by XERBLA."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value.",
       "         > 0: if INFO = i, and i is",
       "            <= N: the QR algorithm failed to compute all the",
       "                  eigenvalues; elements 1:ILO-1 and i+1:N of WR and WI",
       "                  contain those eigenvalues which have converged; if",
       "                  JOBVS = 'V', VS contains the transformation which",
       "                  reduces A to its partially converged Schur form.",
       "            = N+1: the eigenvalues could not be reordered because some",
       "                  eigenvalues were too close to separate (the problem",
       "                  is very ill-conditioned);",
       "            = N+2: after reordering, roundoff changed values of some",
       "                  complex eigenvalues so that leading eigenvalues in",
       "                  the Schur form no longer satisfy SELECT=.TRUE.  This",
       "                  could also be caused by underflow due to scaling."]}},
 "zla_gerfsx_extended"=>
  {"summary"=>
    ["ZLA_GERFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by ZGERFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERRS_N",
     "and ERRS_C for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERRS_N and ERRS_C."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "TRANS_TYPE"=>
      ["[in]",
       "         TRANS_TYPE is INTEGER",
       "    Specifies the transposition operation on A.",
       "    The value is defined by ILATRANS(T) where T is a CHARACTER and",
       "    T    = 'N':  No transpose",
       "         = 'T':  Transpose",
       "         = 'C':  Conjugate transpose"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by ZGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by ZGETRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by ZGETRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by ZLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERRS_N",
       "    and ERRS_C).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERRS_N"=>
      ["[in,out]",
       "         ERRS_N is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERRS_N(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERRS_N(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERRS_C"=>
      ["[in,out]",
       "         ERRS_C is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERRS_C is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERRS_C(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERRS_C(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is DOUBLE PRECISION array, dimension (N)",
       "    Workspace."],
     "DY"=>
      ["[in]",
       "         DY is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is COMPLEX*16 array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERRS_N and ERRS_C may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is DOUBLE PRECISION",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is DOUBLE PRECISION",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to ZGETRS had an illegal",
       "            value"]}},
 "slarre"=>
  {"summary"=>
    ["To find the desired eigenvalues of a given real symmetric",
     "tridiagonal matrix T, SLARRE sets any \"small\" off-diagonal",
     "elements to zero, and for each unreduced block T_i, it finds",
     "(a) a suitable shift at one end of the block's spectrum,",
     "(b) the base representation, T_i - sigma_i I = L_i D_i L_i^T, and",
     "(c) eigenvalues of each L_i D_i L_i^T.",
     "The representations and eigenvalues found are then used by",
     "SSTEMR to compute the eigenvectors of T.",
     "The accuracy varies depending on whether bisection is used to",
     "find a few eigenvalues or the dqds algorithm (subroutine SLASQ2) to",
     "conpute all and then discard any unwanted one.",
     "As an added benefit, SLARRE also outputs the n",
     "Gerschgorin intervals for the matrices L_i D_i L_i^T."],
   "param"=>
    {"RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': (\"All\")   all eigenvalues will be found.",
       "         = 'V': (\"Value\") all eigenvalues in the half-open interval",
       "                          (VL, VU] will be found.",
       "         = 'I': (\"Index\") the IL-th through IU-th eigenvalues (of the",
       "                          entire matrix) will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix. N > 0."],
     "VL"=>
      ["[in,out]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound for the eigenvalues.",
       "         Eigenvalues less than or equal to VL, or greater than VU,",
       "         will not be returned.  VL < VU.",
       "         If RANGE='I' or ='A', SLARRE computes bounds on the desired",
       "         part of the spectrum."],
     "VU"=>
      ["[in,out]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound for the eigenvalues.",
       "         Eigenvalues less than or equal to VL, or greater than VU,",
       "         will not be returned.  VL < VU.",
       "         If RANGE='I' or ='A', SLARRE computes bounds on the desired",
       "         part of the spectrum."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal",
       "         matrix T.",
       "         On exit, the N diagonal elements of the diagonal",
       "         matrices D_i."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N)",
       "         On entry, the first (N-1) entries contain the subdiagonal",
       "         elements of the tridiagonal matrix T; E(N) need not be set.",
       "         On exit, E contains the subdiagonal elements of the unit",
       "         bidiagonal matrices L_i. The entries E( ISPLIT( I ) ),",
       "         1 <= I <= NSPLIT, contain the base points sigma_i on output."],
     "E2"=>
      ["[in,out]",
       "         E2 is REAL array, dimension (N)",
       "         On entry, the first (N-1) entries contain the SQUARES of the",
       "         subdiagonal elements of the tridiagonal matrix T;",
       "         E2(N) need not be set.",
       "         On exit, the entries E2( ISPLIT( I ) ),",
       "         1 <= I <= NSPLIT, have been set to zero"],
     "RTOL1"=>["[in]", "         RTOL1 is REAL"],
     "RTOL2"=>
      ["[in]",
       "         RTOL2 is REAL",
       "          Parameters for bisection.",
       "          An interval [LEFT,RIGHT] has converged if",
       "          RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )"],
     "SPLTOL"=>
      ["[in]",
       "         SPLTOL is REAL",
       "         The threshold for splitting."],
     "NSPLIT"=>
      ["[out]",
       "         NSPLIT is INTEGER",
       "         The number of blocks T splits into. 1 <= NSPLIT <= N."],
     "ISPLIT"=>
      ["[out]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into blocks.",
       "         The first block consists of rows/columns 1 to ISPLIT(1),",
       "         the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),",
       "         etc., and the NSPLIT-th consists of rows/columns",
       "         ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues (of all L_i D_i L_i^T)",
       "         found."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the eigenvalues. The",
       "         eigenvalues of each of the blocks, L_i D_i L_i^T, are",
       "         sorted in ascending order ( SLARRE may use the",
       "         remaining N-M elements as workspace)."],
     "WERR"=>
      ["[out]",
       "         WERR is REAL array, dimension (N)",
       "         The error bound on the corresponding eigenvalue in W."],
     "WGAP"=>
      ["[out]",
       "         WGAP is REAL array, dimension (N)",
       "         The separation from the right neighbor eigenvalue in W.",
       "         The gap is only with respect to the eigenvalues of the same block",
       "         as each block has its own representation tree.",
       "         Exception: at the right end of a block we store the left gap"],
     "IBLOCK"=>
      ["[out]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         The indices of the blocks (submatrices) associated with the",
       "         corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue",
       "         W(i) belongs to the first block from the top, =2 if W(i)",
       "         belongs to the second block, etc."],
     "INDEXW"=>
      ["[out]",
       "         INDEXW is INTEGER array, dimension (N)",
       "         The indices of the eigenvalues within each block (submatrix);",
       "         for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the",
       "         i-th eigenvalue W(i) is the 10-th eigenvalue in block 2"],
     "GERS"=>
      ["[out]",
       "         GERS is REAL array, dimension (2*N)",
       "         The N Gerschgorin intervals (the i-th Gerschgorin interval",
       "         is (GERS(2*i-1), GERS(2*i))."],
     "PIVMIN"=>
      ["[out]",
       "         PIVMIN is REAL",
       "         The minimum pivot in the Sturm sequence for T."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (6*N)",
       "         Workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (5*N)",
       "         Workspace."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         > 0:  A problem occurred in SLARRE.",
       "         < 0:  One of the called subroutines signaled an internal problem.",
       "               Needs inspection of the corresponding parameter IINFO",
       "               for further information.",
       "         =-1:  Problem in SLARRD.",
       "         = 2:  No base representation could be found in MAXTRY iterations.",
       "               Increasing MAXTRY and recompilation might be a remedy.",
       "         =-3:  Problem in SLARRB when computing the refined root",
       "               representation for SLASQ2.",
       "         =-4:  Problem in SLARRB when preforming bisection on the",
       "               desired part of the spectrum.",
       "         =-5:  Problem in SLASQ2.",
       "         =-6:  Problem in SLASQ2."]}},
 "sorm2r"=>
  {"summary"=>
    ["SORM2R overwrites the general real m by n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**T* C  if SIDE = 'L' and TRANS = 'T', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**T if SIDE = 'R' and TRANS = 'T',",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by SGEQRF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left",
       "         = 'R': apply Q or Q**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'T': apply Q**T (Transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         SGEQRF in the first k columns of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGEQRF."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zlarcm"=>
  {"summary"=>
    ["ZLARCM performs a very simple matrix-matrix multiplication:",
     "         C := A * B,",
     "where A is M by M and real; B is M by N and complex;",
     "C is M by N and complex."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A and of the matrix C.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns and rows of the matrix B and",
       "         the number of columns of the matrix C.",
       "         N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA, M)",
       "         On entry, A contains the M by M matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >=max(1,M)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, B contains the M by N matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >=max(1,M)."],
     "C"=>
      ["[out]",
       "         C is COMPLEX*16 array, dimension (LDC, N)",
       "         On exit, C contains the M by N matrix C."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >=max(1,M)."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (2*M*N)"]}},
 "strsna"=>
  {"summary"=>
    ["STRSNA estimates reciprocal condition numbers for specified",
     "eigenvalues and/or right eigenvectors of a real upper",
     "quasi-triangular matrix T (or of any matrix Q*T*Q**T with Q",
     "orthogonal).",
     "T must be in Schur canonical form (as returned by SHSEQR), that is,",
     "block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each",
     "2-by-2 diagonal block has its diagonal elements equal and its",
     "off-diagonal elements of opposite sign."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for",
       "         eigenvalues (S) or eigenvectors (SEP):",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for eigenvectors only (SEP);",
       "         = 'B': for both eigenvalues and eigenvectors (S and SEP)."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute condition numbers for all eigenpairs;",
       "         = 'S': compute condition numbers for selected eigenpairs",
       "                specified by the array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenpairs for which",
       "         condition numbers are required. To select condition numbers",
       "         for the eigenpair corresponding to a real eigenvalue w(j),",
       "         SELECT(j) must be set to .TRUE.. To select condition numbers",
       "         corresponding to a complex conjugate pair of eigenvalues w(j)",
       "         and w(j+1), either SELECT(j) or SELECT(j+1) or both, must be",
       "         set to .TRUE..",
       "         If HOWMNY = 'A', SELECT is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (LDT,N)",
       "         The upper quasi-triangular matrix T, in Schur canonical form."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL array, dimension (LDVL,M)",
       "         If JOB = 'E' or 'B', VL must contain left eigenvectors of T",
       "         (or of any Q*T*Q**T with Q orthogonal), corresponding to the",
       "         eigenpairs specified by HOWMNY and SELECT. The eigenvectors",
       "         must be stored in consecutive columns of VL, as returned by",
       "         SHSEIN or STREVC.",
       "         If JOB = 'V', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= 1; and if JOB = 'E' or 'B', LDVL >= N."],
     "VR"=>
      ["[in]",
       "         VR is REAL array, dimension (LDVR,M)",
       "         If JOB = 'E' or 'B', VR must contain right eigenvectors of T",
       "         (or of any Q*T*Q**T with Q orthogonal), corresponding to the",
       "         eigenpairs specified by HOWMNY and SELECT. The eigenvectors",
       "         must be stored in consecutive columns of VR, as returned by",
       "         SHSEIN or STREVC.",
       "         If JOB = 'V', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= 1; and if JOB = 'E' or 'B', LDVR >= N."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (MM)",
       "         If JOB = 'E' or 'B', the reciprocal condition numbers of the",
       "         selected eigenvalues, stored in consecutive elements of the",
       "         array. For a complex conjugate pair of eigenvalues two",
       "         consecutive elements of S are set to the same value. Thus",
       "         S(j), SEP(j), and the j-th columns of VL and VR all",
       "         correspond to the same eigenpair (but not in general the",
       "         j-th eigenpair, unless all eigenpairs are selected).",
       "         If JOB = 'V', S is not referenced."],
     "SEP"=>
      ["[out]",
       "         SEP is REAL array, dimension (MM)",
       "         If JOB = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the selected eigenvectors, stored in consecutive",
       "         elements of the array. For a complex eigenvector two",
       "         consecutive elements of SEP are set to the same value. If",
       "         the eigenvalues cannot be reordered to compute SEP(j), SEP(j)",
       "         is set to 0; this can only occur when the true value would be",
       "         very small anyway.",
       "         If JOB = 'E', SEP is not referenced."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of elements in the arrays S (if JOB = 'E' or 'B')",
       "          and/or SEP (if JOB = 'V' or 'B'). MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of elements of the arrays S and/or SEP actually",
       "         used to store the estimated condition numbers.",
       "         If HOWMNY = 'A', M is set to N."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (LDWORK,N+6)",
       "         If JOB = 'E', WORK is not referenced."],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         LDWORK >= 1; and if JOB = 'V' or 'B', LDWORK >= N."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (2*(N-1))",
       "         If JOB = 'E', IWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zgbsvx"=>
  {"summary"=>
    ["ZGBSVX uses the LU factorization to compute the solution to a complex",
     "system of linear equations A * X = B, A**T * X = B, or A**H * X = B,",
     "where A is a band matrix of order N with KL subdiagonals and KU",
     "superdiagonals, and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "zsymv"=>
  {"summary"=>
    ["ZSYMV  performs the matrix-vector  operation",
     "   y := alpha*A*x + beta*y,",
     "where alpha and beta are scalars, x and y are n element vectors and",
     "A is an n by n symmetric matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the array A is to be referenced as",
       "          follows:",
       "             UPLO = 'U' or 'u'   Only the upper triangular part of A",
       "                                 is to be referenced.",
       "             UPLO = 'L' or 'l'   Only the lower triangular part of A",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the order of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX*16",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension ( LDA, N )",
       "          Before entry, with  UPLO = 'U' or 'u', the leading n by n",
       "          upper triangular part of the array A must contain the upper",
       "          triangular part of the symmetric matrix and the strictly",
       "          lower triangular part of A is not referenced.",
       "          Before entry, with UPLO = 'L' or 'l', the leading n by n",
       "          lower triangular part of the array A must contain the lower",
       "          triangular part of the symmetric matrix and the strictly",
       "          upper triangular part of A is not referenced.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, N ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCX ) ).",
       "          Before entry, the incremented array X must contain the N-",
       "          element vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is COMPLEX*16",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCY ) ).",
       "          Before entry, the incremented array Y must contain the n",
       "          element vector y. On exit, Y is overwritten by the updated",
       "          vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit."]}},
 "ztgevc"=>
  {"summary"=>
    ["ZTGEVC computes some or all of the right and/or left eigenvectors of",
     "a pair of complex matrices (S,P), where S and P are upper triangular.",
     "Matrix pairs of this type are produced by the generalized Schur",
     "factorization of a complex matrix pair (A,B):",
     "   A = Q*S*Z**H,  B = Q*P*Z**H",
     "as computed by ZGGHRD + ZHGEQZ.",
     "The right eigenvector x and the left eigenvector y of (S,P)",
     "corresponding to an eigenvalue w are defined by:",
     "   S*x = w*P*x,  (y**H)*S = w*(y**H)*P,",
     "where y**H denotes the conjugate tranpose of y.",
     "The eigenvalues are not input to this routine, but are computed",
     "directly from the diagonal elements of S and P.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of (S,P), or the products Z*X and/or Q*Y,",
     "where Z and Q are input matrices.",
     "If Q and Z are the unitary factors from the generalized Schur",
     "factorization of a matrix pair (A,B), then Z*X and Q*Y",
     "are the matrices of right and left eigenvectors of (A,B)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R': compute right eigenvectors only;",
       "         = 'L': compute left eigenvectors only;",
       "         = 'B': compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute all right and/or left eigenvectors;",
       "         = 'B': compute all right and/or left eigenvectors,",
       "                backtransformed by the matrices in VR and/or VL;",
       "         = 'S': compute selected right and/or left eigenvectors,",
       "                specified by the logical array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY='S', SELECT specifies the eigenvectors to be",
       "         computed.  The eigenvector corresponding to the j-th",
       "         eigenvalue is computed if SELECT(j) = .TRUE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices S and P.  N >= 0."],
     "S"=>
      ["[in]",
       "         S is COMPLEX*16 array, dimension (LDS,N)",
       "         The upper triangular matrix S from a generalized Schur",
       "         factorization, as computed by ZHGEQZ."],
     "LDS"=>
      ["[in]",
       "         LDS is INTEGER",
       "         The leading dimension of array S.  LDS >= max(1,N)."],
     "P"=>
      ["[in]",
       "         P is COMPLEX*16 array, dimension (LDP,N)",
       "         The upper triangular matrix P from a generalized Schur",
       "         factorization, as computed by ZHGEQZ.  P must have real",
       "         diagonal elements."],
     "LDP"=>
      ["[in]",
       "         LDP is INTEGER",
       "         The leading dimension of array P.  LDP >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is COMPLEX*16 array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Q",
       "         of left Schur vectors returned by ZHGEQZ).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of (S,P);",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of (S,P) specified by",
       "                     SELECT, stored consecutively in the columns of",
       "                     VL, in the same order as their eigenvalues.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of array VL.  LDVL >= 1, and if",
       "         SIDE = 'L' or 'l' or 'B' or 'b', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is COMPLEX*16 array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Q (usually the unitary matrix Z",
       "         of right Schur vectors returned by ZHGEQZ).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of (S,P);",
       "         if HOWMNY = 'B', the matrix Z*X;",
       "         if HOWMNY = 'S', the right eigenvectors of (S,P) specified by",
       "                     SELECT, stored consecutively in the columns of",
       "                     VR, in the same order as their eigenvalues.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1, and if",
       "         SIDE = 'R' or 'B', LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.  If HOWMNY = 'A' or 'B', M",
       "         is set to N.  Each selected eigenvector occupies one column."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ssycon"=>
  {"summary"=>
    ["SSYCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric matrix A using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by SSYTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by SSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ztpttf"=>
  {"summary"=>
    ["ZTPTTF copies a triangular matrix A from standard packed format (TP)",
     "to rectangular full packed format (TF)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF in Normal format is wanted;",
       "         = 'C':  ARF in Conjugate-transpose format is wanted."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "ARF"=>
      ["[out]",
       "         ARF is COMPLEX*16 array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dppsvx"=>
  {"summary"=>
    ["DPPSVX uses the Cholesky factorization A = U**T*U or A = L*L**T to",
     "compute the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite matrix stored in",
     "packed format and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "zspmv"=>
  {"summary"=>
    ["ZSPMV  performs the matrix-vector operation",
     "   y := alpha*A*x + beta*y,",
     "where alpha and beta are scalars, x and y are n element vectors and",
     "A is an n by n symmetric matrix, supplied in packed form."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the matrix A is supplied in the packed",
       "          array AP as follows:",
       "             UPLO = 'U' or 'u'   The upper triangular part of A is",
       "                                 supplied in AP.",
       "             UPLO = 'L' or 'l'   The lower triangular part of A is",
       "                                 supplied in AP.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the order of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX*16",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension at least",
       "          ( ( N*( N + 1 ) )/2 ).",
       "          Before entry, with UPLO = 'U' or 'u', the array AP must",
       "          contain the upper triangular part of the symmetric matrix",
       "          packed sequentially, column by column, so that AP( 1 )",
       "          contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 )",
       "          and a( 2, 2 ) respectively, and so on.",
       "          Before entry, with UPLO = 'L' or 'l', the array AP must",
       "          contain the lower triangular part of the symmetric matrix",
       "          packed sequentially, column by column, so that AP( 1 )",
       "          contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 )",
       "          and a( 3, 1 ) respectively, and so on.",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCX ) ).",
       "          Before entry, the incremented array X must contain the N-",
       "          element vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is COMPLEX*16",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCY ) ).",
       "          Before entry, the incremented array Y must contain the n",
       "          element vector y. On exit, Y is overwritten by the updated",
       "          vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit."]}},
 "cporfsx"=>
  {"summary"=>
    ["   CPORFSX improves the computed solution to a system of linear",
     "   equations when the coefficient matrix is symmetric positive",
     "   definite, and provides error bounds and backward error estimates",
     "   for the solution.  In addition to normwise error bound, the code",
     "   provides maximum componentwise error bound if possible.  See",
     "   comments for ERR_BNDS_NORM and ERR_BNDS_COMP for details of the",
     "   error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED and S",
     "   below. In this case, the solution and error bounds returned are",
     "   for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'Y':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(S) * A * diag(S).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "    upper triangular part of A contains the upper triangular part",
       "    of the matrix A, and the strictly lower triangular part of A",
       "    is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "    triangular part of A contains the lower triangular part of",
       "    the matrix A, and the strictly upper triangular part of A is",
       "    not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by SPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "S"=>
      ["[in,out]",
       "         S is REAL array, dimension (N)",
       "    The row scale factors for A.  If EQUED = 'Y', A is multiplied on",
       "    the left and right by diag(S).  S is an input argument if FACT =",
       "    'F'; otherwise, S is an output argument.  If FACT = 'F' and EQUED",
       "    = 'Y', each element of S must be positive.  If S is output, each",
       "    element of S is a power of the radix. If S is input, each element",
       "    of S should be a power of the radix to ensure a reliable solution",
       "    and error estimates. Scaling by powers of the radix does not cause",
       "    rounding errors unless the result underflows or overflows.",
       "    Rounding errors during scaling lead to refining with a matrix that",
       "    is not equivalent to the input matrix, producing error estimates",
       "    that may not be reliable."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by SGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is REAL array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is REAL array, dimension NPARAMS",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "claqr4"=>
  {"summary"=>
    ["   CLAQR4 implements one level of recursion for CLAQR0.",
     "   It is a complete implementation of the small bulge multi-shift",
     "   QR algorithm.  It may be called by CLAQR0 and, for large enough",
     "   deflation window size, it may be called by CLAQR3.  This",
     "   subroutine is identical to CLAQR0 except that it calls CLAQR2",
     "   instead of CLAQR3.",
     "   CLAQR4 computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**H, where T is an upper triangular matrix (the",
     "   Schur form), and Z is the unitary matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input unitary",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the unitary matrix Q:  A = Q*H*Q**H = (QZ)*H*(QZ)**H."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N and, if ILO.GT.1,",
       "          H(ILO,ILO-1) is zero. ILO and IHI are normally set by a",
       "          previous call to CGEBAL, and then passed to CGEHRD when the",
       "          matrix output by CGEBAL is reduced to Hessenberg form.",
       "          Otherwise, ILO and IHI should be set to 1 and N,",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and WANTT is .TRUE., then H",
       "          contains the upper triangular matrix T from the Schur",
       "          decomposition (the Schur form). If INFO = 0 and WANT is",
       "          .FALSE., then the contents of H are unspecified on exit.",
       "          (The output value of H when INFO.GT.0 is given under the",
       "          description of INFO below.)",
       "          This subroutine may explicitly set H(i,j) = 0 for i.GT.j and",
       "          j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX array, dimension (N)",
       "          The computed eigenvalues of H(ILO:IHI,ILO:IHI) are stored",
       "          in W(ILO:IHI). If WANTT is .TRUE., then the eigenvalues are",
       "          stored in the same order as on the diagonal of the Schur",
       "          form returned in H, with W(i) = H(i,i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "          Specify the rows of Z to which transformations must be",
       "          applied if WANTZ is .TRUE..",
       "          1 .LE. ILOZ .LE. ILO; IHI .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ,IHI)",
       "          If WANTZ is .FALSE., then Z is not referenced.",
       "          If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is",
       "          replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the",
       "          orthogonal Schur factor of H(ILO:IHI,ILO:IHI).",
       "          (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if WANTZ is .TRUE.",
       "          then LDZ.GE.MAX(1,IHIZ).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension LWORK",
       "          On exit, if LWORK = -1, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient, but LWORK typically as large as 6*N may",
       "          be required for optimal performance.  A workspace query",
       "          to determine the optimal workspace size is recommended.",
       "          If LWORK = -1, then CLAQR4 does a workspace query.",
       "          In this case, CLAQR4 checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .GT. 0:  if INFO = i, CLAQR4 failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and WANT is .FALSE., then on exit,",
       "               the remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is a unitary matrix.  The final",
       "               value of  H is upper Hessenberg and triangular in",
       "               rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                 (final value of Z(ILO:IHI,ILOZ:IHIZ)",
       "                  =  (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U",
       "               where U is the unitary matrix in (*) (regard-",
       "               less of the value of WANTT.)",
       "               If INFO .GT. 0 and WANTZ is .FALSE., then Z is not",
       "               accessed."]}},
 "clar1v"=>
  {"summary"=>
    ["CLAR1V computes the (scaled) r-th column of the inverse of",
     "the sumbmatrix in rows B1 through BN of the tridiagonal matrix",
     "L D L**T - sigma I. When sigma is close to an eigenvalue, the",
     "computed vector is an accurate eigenvector. Usually, r corresponds",
     "to the index where the eigenvector is largest in magnitude.",
     "The following steps accomplish this computation :",
     "(a) Stationary qd transform,  L D L**T - sigma I = L(+) D(+) L(+)**T,",
     "(b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,",
     "(c) Computation of the diagonal elements of the inverse of",
     "    L D L**T - sigma I by combining the above transforms, and choosing",
     "    r as the index where the diagonal of the inverse is (one of the)",
     "    largest in magnitude.",
     "(d) Computation of the (scaled) r-th column of the inverse using the",
     "    twisted factorization obtained by combining the top part of the",
     "    the stationary and the bottom part of the progressive transform."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix L D L**T."],
     "B1"=>
      ["[in]",
       "         B1 is INTEGER",
       "          First index of the submatrix of L D L**T."],
     "BN"=>
      ["[in]",
       "         BN is INTEGER",
       "          Last index of the submatrix of L D L**T."],
     "LAMBDA"=>
      ["[in]",
       "         LAMBDA is REAL",
       "          The shift. In order to compute an accurate eigenvector,",
       "          LAMBDA should be a good approximation to an eigenvalue",
       "          of L D L**T."],
     "L"=>
      ["[in]",
       "         L is REAL array, dimension (N-1)",
       "          The (n-1) subdiagonal elements of the unit bidiagonal matrix",
       "          L, in elements 1 to N-1."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "          The n diagonal elements of the diagonal matrix D."],
     "LD"=>
      ["[in]",
       "         LD is REAL array, dimension (N-1)",
       "          The n-1 elements L(i)*D(i)."],
     "LLD"=>
      ["[in]",
       "         LLD is REAL array, dimension (N-1)",
       "          The n-1 elements L(i)*L(i)*D(i)."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "          The minimum pivot in the Sturm sequence."],
     "GAPTOL"=>
      ["[in]",
       "         GAPTOL is REAL",
       "          Tolerance that indicates when eigenvector entries are negligible",
       "          w.r.t. their contribution to the residual."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (N)",
       "          On input, all entries of Z must be set to 0.",
       "          On output, Z contains the (scaled) r-th column of the",
       "          inverse. The scaling is such that Z(R) equals 1."],
     "WANTNC"=>
      ["[in]",
       "         WANTNC is LOGICAL",
       "          Specifies whether NEGCNT has to be computed."],
     "NEGCNT"=>
      ["[out]",
       "         NEGCNT is INTEGER",
       "          If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin",
       "          in the  matrix factorization L D L**T, and NEGCNT = -1 otherwise."],
     "ZTZ"=>
      ["[out]",
       "         ZTZ is REAL",
       "          The square of the 2-norm of Z."],
     "MINGMA"=>
      ["[out]",
       "         MINGMA is REAL",
       "          The reciprocal of the largest (in magnitude) diagonal",
       "          element of the inverse of L D L**T - sigma I."],
     "R"=>
      ["[in,out]",
       "         R is INTEGER",
       "          The twist index for the twisted factorization used to",
       "          compute Z.",
       "          On input, 0 <= R <= N. If R is input as 0, R is set to",
       "          the index where (L D L**T - sigma I)^{-1} is largest",
       "          in magnitude. If 1 <= R <= N, R is unchanged.",
       "          On output, R contains the twist index used to compute Z.",
       "          Ideally, R designates the position of the maximum entry in the",
       "          eigenvector."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension (2)",
       "          The support of the vector in Z, i.e., the vector Z is",
       "          nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 )."],
     "NRMINV"=>
      ["[out]", "         NRMINV is REAL", "          NRMINV = 1/SQRT( ZTZ )"],
     "RESID"=>
      ["[out]",
       "         RESID is REAL",
       "          The residual of the FP vector.",
       "          RESID = ABS( MINGMA )/SQRT( ZTZ )"],
     "RQCORR"=>
      ["[out]",
       "         RQCORR is REAL",
       "          The Rayleigh Quotient correction to LAMBDA.",
       "          RQCORR = MINGMA*TMP"],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"]}},
 "cheequb"=>
  {"summary"=>
    ["CHEEQUB computes row and column scalings intended to equilibrate a",
     "Hermitian matrix A (with respect to the Euclidean norm) and reduce",
     "its condition number. The scale factors S are computed by the BIN",
     "algorithm (see references) so that the scaled matrix B with elements",
     "B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of",
     "the smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The N-by-N Hermitian matrix whose scaling factors are to be",
       "         computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is REAL",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i). If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Largest absolute value of any matrix element. If AMAX is",
       "         very close to overflow or very close to underflow, the",
       "         matrix should be scaled."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "dppequ"=>
  {"summary"=>
    ["DPPEQU computes row and column scalings intended to equilibrate a",
     "symmetric positive definite matrix A in packed storage and reduce",
     "its condition number (with respect to the two-norm).  S contains the",
     "scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix",
     "B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal.",
     "This choice of S puts the condition number of B within a factor N of",
     "the smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the symmetric matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is DOUBLE PRECISION",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "cgesvxx"=>
  {"summary"=>
    ["   CGESVXX uses the LU factorization to compute the solution to a",
     "   complex system of linear equations  A * X = B,  where A is an",
     "   N-by-N matrix and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. CGESVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   CGESVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   CGESVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what CGESVXX would itself produce."],
   "param"=>nil},
 "zhpgv"=>
  {"summary"=>
    ["ZHPGV computes all the eigenvalues and, optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be Hermitian, stored in packed format,",
     "and B is also positive definite."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H, in the same storage",
       "         format as B."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors.  The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (max(1, 2*N-1))"],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  ZPPTRF or ZHPEV returned an error code:",
       "            <= N:  if INFO = i, ZHPEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not convergeto zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= n, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "dlarnv"=>
  {"summary"=>
    ["DLARNV returns a vector of n random real numbers from a uniform or",
     "normal distribution."],
   "param"=>
    {"IDIST"=>
      ["[in]",
       "         IDIST is INTEGER",
       "         Specifies the distribution of the random numbers:",
       "         = 1:  uniform (0,1)",
       "         = 2:  uniform (-1,1)",
       "         = 3:  normal (0,1)"],
     "ISEED"=>
      ["[in,out]",
       "         ISEED is INTEGER array, dimension (4)",
       "         On entry, the seed of the random number generator; the array",
       "         elements must be between 0 and 4095, and ISEED(4) must be",
       "         odd.",
       "         On exit, the seed is updated."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of random numbers to be generated."],
     "X"=>
      ["[out]",
       "         X is DOUBLE PRECISION array, dimension (N)",
       "         The generated random numbers."]}},
 "sspgvx"=>
  {"summary"=>
    ["SSPGVX computes selected eigenvalues, and optionally, eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A",
     "and B are assumed to be symmetric, stored in packed storage, and B",
     "is also positive definite.  Eigenvalues and eigenvectors can be",
     "selected by specifying either a range of values or a range of indices",
     "for the desired eigenvalues."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A and B are stored;",
       "         = 'L':  Lower triangle of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix pencil (A,B).  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T, in the same storage",
       "         format as B."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (8*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  SPPTRF or SSPEVX returned an error code:",
       "            <= N:  if INFO = i, SSPEVX failed to converge;",
       "                   i eigenvectors failed to converge.  Their indices",
       "                   are stored in array IFAIL.",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "ztgsen"=>
  {"summary"=>
    ["ZTGSEN reorders the generalized Schur decomposition of a complex",
     "matrix pair (A, B) (in terms of an unitary equivalence trans-",
     "formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues",
     "appears in the leading diagonal blocks of the pair (A,B). The leading",
     "columns of Q and Z form unitary bases of the corresponding left and",
     "right eigenspaces (deflating subspaces). (A, B) must be in",
     "generalized Schur canonical form, that is, A and B are both upper",
     "triangular.",
     "ZTGSEN also computes the generalized eigenvalues",
     "         w(j)= ALPHA(j) / BETA(j)",
     "of the reordered matrix pair (A, B).",
     "Optionally, the routine computes estimates of reciprocal condition",
     "numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11),",
     "(A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s)",
     "between the matrix pairs (A11, B11) and (A22,B22) that correspond to",
     "the selected cluster and the eigenvalues outside the cluster, resp.,",
     "and norms of \"projections\" onto left and right eigenspaces w.r.t.",
     "the selected cluster in the (1,1)-block."],
   "param"=>
    {"IJOB"=>
      ["[in]",
       "         IJOB is integer",
       "         Specifies whether condition numbers are required for the",
       "         cluster of eigenvalues (PL and PR) or the deflating subspaces",
       "         (Difu and Difl):",
       "          =0: Only reorder w.r.t. SELECT. No extras.",
       "          =1: Reciprocal of norms of \"projections\" onto left and right",
       "              eigenspaces w.r.t. the selected cluster (PL and PR).",
       "          =2: Upper bounds on Difu and Difl. F-norm-based estimate",
       "              (DIF(1:2)).",
       "          =3: Estimate of Difu and Difl. 1-norm-based estimate",
       "              (DIF(1:2)).",
       "              About 5 times as expensive as IJOB = 2.",
       "          =4: Compute PL, PR and DIF (i.e. 0, 1 and 2 above): Economic",
       "              version to get it all.",
       "          =5: Compute PL, PR and DIF (i.e. 0, 1 and 3 above)"],
     "WANTQ"=>
      ["[in]",
       "         WANTQ is LOGICAL",
       "         .TRUE. : update the left transformation matrix Q;",
       "         .FALSE.: do not update Q."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         .TRUE. : update the right transformation matrix Z;",
       "         .FALSE.: do not update Z."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         SELECT specifies the eigenvalues in the selected cluster. To",
       "         select an eigenvalue w(j), SELECT(j) must be set to",
       "         .TRUE.."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension(LDA,N)",
       "         On entry, the upper triangular matrix A, in generalized",
       "         Schur canonical form.",
       "         On exit, A is overwritten by the reordered matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension(LDB,N)",
       "         On entry, the upper triangular matrix B, in generalized",
       "         Schur canonical form.",
       "         On exit, B is overwritten by the reordered matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX*16 array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX*16 array, dimension (N)",
       "         The diagonal elements of A and B, respectively,",
       "         when the pair (A,B) has been reduced to generalized Schur",
       "         form.  ALPHA(i)/BETA(i) i=1,...,N are the generalized",
       "         eigenvalues."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,N)",
       "         On entry, if WANTQ = .TRUE., Q is an N-by-N matrix.",
       "         On exit, Q has been postmultiplied by the left unitary",
       "         transformation matrix which reorder (A, B); The leading M",
       "         columns of Q form orthonormal bases for the specified pair of",
       "         left eigenspaces (deflating subspaces).",
       "         If WANTQ = .FALSE., Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= 1.",
       "         If WANTQ = .TRUE., LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ,N)",
       "         On entry, if WANTZ = .TRUE., Z is an N-by-N matrix.",
       "         On exit, Z has been postmultiplied by the left unitary",
       "         transformation matrix which reorder (A, B); The leading M",
       "         columns of Z form orthonormal bases for the specified pair of",
       "         left eigenspaces (deflating subspaces).",
       "         If WANTZ = .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= 1.",
       "         If WANTZ = .TRUE., LDZ >= N."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The dimension of the specified pair of left and right",
       "         eigenspaces, (deflating subspaces) 0 <= M <= N."],
     "PL"=>["[out]", "         PL is DOUBLE PRECISION"],
     "PR"=>
      ["[out]",
       "         PR is DOUBLE PRECISION",
       "         If IJOB = 1, 4 or 5, PL, PR are lower bounds on the",
       "         reciprocal  of the norm of \"projections\" onto left and right",
       "         eigenspace with respect to the selected cluster.",
       "         0 < PL, PR <= 1.",
       "         If M = 0 or M = N, PL = PR  = 1.",
       "         If IJOB = 0, 2 or 3 PL, PR are not referenced."],
     "DIF"=>
      ["[out]",
       "         DIF is DOUBLE PRECISION array, dimension (2).",
       "         If IJOB >= 2, DIF(1:2) store the estimates of Difu and Difl.",
       "         If IJOB = 2 or 4, DIF(1:2) are F-norm-based upper bounds on",
       "         Difu and Difl. If IJOB = 3 or 5, DIF(1:2) are 1-norm-based",
       "         estimates of Difu and Difl, computed using reversed",
       "         communication with ZLACN2.",
       "         If M = 0 or N, DIF(1:2) = F-norm([A, B]).",
       "         If IJOB = 0 or 1, DIF is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >=  1",
       "         If IJOB = 1, 2 or 4, LWORK >=  2*M*(N-M)",
       "         If IJOB = 3 or 5, LWORK >=  4*M*(N-M)",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK. LIWORK >= 1.",
       "         If IJOB = 1, 2 or 4, LIWORK >=  N+2;",
       "         If IJOB = 3 or 5, LIWORK >= MAX(N+2, 2*M*(N-M));",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "           =0: Successful exit.",
       "           <0: If INFO = -i, the i-th argument had an illegal value.",
       "           =1: Reordering of (A, B) failed because the transformed",
       "               matrix pair (A, B) would be too far from generalized",
       "               Schur form; the problem is very ill-conditioned.",
       "               (A, B) may have been partially reordered.",
       "               If requested, 0 is returned in DIF(*), PL and PR."]}},
 "zhetf2"=>
  {"summary"=>
    ["ZHETF2 computes the factorization of a complex Hermitian matrix A",
     "using the Bunch-Kaufman diagonal pivoting method:",
     "   A = U*D*U**H  or  A = L*D*L**H",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**H is the conjugate transpose of U, and D is",
     "Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "zgelss"=>
  {"summary"=>
    ["ZGELSS computes the minimum norm solution to a complex linear",
     "least squares problem:",
     "Minimize 2-norm(| b - A*x |).",
     "using the singular value decomposition (SVD) of A. A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix",
     "X.",
     "The effective rank of A is determined by treating as zero those",
     "singular values which are less than RCOND times the largest singular",
     "value."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the first min(m,n) rows of A are overwritten with",
       "         its right singular vectors, stored rowwise."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, B is overwritten by the N-by-NRHS solution matrix X.",
       "         If m >= n and RANK = n, the residual sum-of-squares for",
       "         the solution in the i-th column is given by the sum of",
       "         squares of the modulus of elements n+1:m in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M,N)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The singular values of A in decreasing order.",
       "         The condition number of A in the 2-norm = S(1)/S(min(m,n))."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "         RCOND is used to determine the effective rank of A.",
       "         Singular values S(i) <= RCOND*S(1) are treated as zero.",
       "         If RCOND < 0, machine precision is used instead."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the number of singular values",
       "         which are greater than RCOND*S(1)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= 1, and also:",
       "         LWORK >=  2*min(M,N) + max(M,N,NRHS)",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (5*min(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  the algorithm for computing the SVD failed to converge;",
       "               if INFO = i, i off-diagonal elements of an intermediate",
       "               bidiagonal form did not converge to zero."]}},
 "clatrz"=>
  {"summary"=>
    ["CLATRZ factors the M-by-(M+L) complex upper trapezoidal matrix",
     "[ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R  0 ) * Z by means",
     "of unitary transformations, where  Z is an (M+L)-by-(M+L) unitary",
     "matrix and, R and A1 are M-by-M upper triangular matrices."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing the",
       "         meaningful part of the Householder vectors. N-M >= L >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the leading M-by-N upper trapezoidal part of the",
       "         array A must contain the matrix to be factorized.",
       "         On exit, the leading M-by-M upper triangular part of A",
       "         contains the upper triangular matrix R, and elements N-L+1 to",
       "         N of the first M rows of A, with the array TAU, represent the",
       "         unitary matrix Z as a product of M elementary reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (M)",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (M)"]}},
 "cggsvd3"=>
  {"summary"=>
    ["CGGSVD3 computes the generalized singular value decomposition (GSVD)",
     "of an M-by-N complex matrix A and P-by-N complex matrix B:",
     "      U**H*A*Q = D1*( 0 R ),    V**H*B*Q = D2*( 0 R )",
     "where U, V and Q are unitary matrices.",
     "Let K+L = the effective numerical rank of the",
     "matrix (A**H,B**H)**H, then R is a (K+L)-by-(K+L) nonsingular upper",
     "triangular matrix, D1 and D2 are M-by-(K+L) and P-by-(K+L) \"diagonal\"",
     "matrices and of the following structures, respectively:",
     "If M-K-L >= 0,",
     "                    K  L",
     "       D1 =     K ( I  0 )",
     "                L ( 0  C )",
     "            M-K-L ( 0  0 )",
     "                  K  L",
     "       D2 =   L ( 0  S )",
     "            P-L ( 0  0 )",
     "                N-K-L  K    L",
     "  ( 0 R ) = K (  0   R11  R12 )",
     "            L (  0    0   R22 )",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(K+L) ),",
     "  S = diag( BETA(K+1),  ... , BETA(K+L) ),",
     "  C**2 + S**2 = I.",
     "  R is stored in A(1:K+L,N-K-L+1:N) on exit.",
     "If M-K-L < 0,",
     "                  K M-K K+L-M",
     "       D1 =   K ( I  0    0   )",
     "            M-K ( 0  C    0   )",
     "                    K M-K K+L-M",
     "       D2 =   M-K ( 0  S    0  )",
     "            K+L-M ( 0  0    I  )",
     "              P-L ( 0  0    0  )",
     "                   N-K-L  K   M-K  K+L-M",
     "  ( 0 R ) =     K ( 0    R11  R12  R13  )",
     "              M-K ( 0     0   R22  R23  )",
     "            K+L-M ( 0     0    0   R33  )",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(M) ),",
     "  S = diag( BETA(K+1),  ... , BETA(M) ),",
     "  C**2 + S**2 = I.",
     "  (R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N), and R33 is stored",
     "  ( 0  R22 R23 )",
     "  in B(M-K+1:L,N+M-K-L+1:N) on exit.",
     "The routine computes C, S, R, and optionally the unitary",
     "transformation matrices U, V and Q.",
     "In particular, if B is an N-by-N nonsingular matrix, then the GSVD of",
     "A and B implicitly gives the SVD of A*inv(B):",
     "                     A*inv(B) = U*(D1*inv(D2))*V**H.",
     "If ( A**H,B**H)**H has orthonormal columns, then the GSVD of A and B is also",
     "equal to the CS decomposition of A and B. Furthermore, the GSVD can",
     "be used to derive the solution of the eigenvalue problem:",
     "                     A**H*A x = lambda* B**H*B x.",
     "In some literature, the GSVD of A and B is presented in the form",
     "                 U**H*A*X = ( 0 D1 ),   V**H*B*X = ( 0 D2 )",
     "where U and V are orthogonal and X is nonsingular, and D1 and D2 are",
     "``diagonal''.  The former GSVD form can be converted to the latter",
     "form by taking the nonsingular matrix X as",
     "                      X = Q*(  I   0    )",
     "                            (  0 inv(R) )"],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  Unitary matrix U is computed;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  Unitary matrix V is computed;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Unitary matrix Q is computed;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "K"=>["[out]", "         K is INTEGER"],
     "L"=>
      ["[out]",
       "         L is INTEGER",
       "         On exit, K and L specify the dimension of the subblocks",
       "         described in Purpose.",
       "         K + L = effective numerical rank of (A**H,B**H)**H."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A contains the triangular matrix R, or part of R.",
       "         See Purpose for details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, B contains part of the triangular matrix R if",
       "         M-K-L < 0.  See Purpose for details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "ALPHA"=>["[out]", "         ALPHA is REAL array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         On exit, ALPHA and BETA contain the generalized singular",
       "         value pairs of A and B;",
       "           ALPHA(1:K) = 1,",
       "           BETA(1:K)  = 0,",
       "         and if M-K-L >= 0,",
       "           ALPHA(K+1:K+L) = C,",
       "           BETA(K+1:K+L)  = S,",
       "         or if M-K-L < 0,",
       "           ALPHA(K+1:M)=C, ALPHA(M+1:K+L)=0",
       "           BETA(K+1:M) =S, BETA(M+1:K+L) =1",
       "         and",
       "           ALPHA(K+L+1:N) = 0",
       "           BETA(K+L+1:N)  = 0"],
     "U"=>
      ["[out]",
       "         U is COMPLEX array, dimension (LDU,M)",
       "         If JOBU = 'U', U contains the M-by-M unitary matrix U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[out]",
       "         V is COMPLEX array, dimension (LDV,P)",
       "         If JOBV = 'V', V contains the P-by-P unitary matrix V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX array, dimension (LDQ,N)",
       "         If JOBQ = 'Q', Q contains the N-by-N unitary matrix Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N)",
       "         On exit, IWORK stores the sorting information. More",
       "         precisely, the following loop will sort ALPHA",
       "            for I = K+1, min(M,K+L)",
       "                swap ALPHA(I) and ALPHA(IWORK(I))",
       "            endfor",
       "         such that ALPHA(1) >= ALPHA(2) >= ... >= ALPHA(N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, the Jacobi-type procedure failed to",
       "               converge.  For further details, see subroutine CTGSJA."]}},
 "zungtr"=>
  {"summary"=>
    ["ZUNGTR generates a complex unitary matrix Q which is defined as the",
     "product of n-1 elementary reflectors of order N, as returned by",
     "ZHETRD:",
     "if UPLO = 'U', Q = H(n-1) . . . H(2) H(1),",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(n-1)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangle of A contains elementary reflectors",
       "                from ZHETRD;",
       "         = 'L': Lower triangle of A contains elementary reflectors",
       "                from ZHETRD."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by ZHETRD.",
       "         On exit, the N-by-N unitary matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= N."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZHETRD."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= N-1.",
       "         For optimum performance LWORK >= (N-1)*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlaqps"=>
  {"summary"=>
    ["ZLAQPS computes a step of QR factorization with column pivoting",
     "of a complex M-by-N matrix A by using Blas-3.  It tries to factorize",
     "NB columns from A starting from the row OFFSET+1, and updates all",
     "of the matrix with Blas-3 xGEMM.",
     "In some cases, due to catastrophic cancellations, it cannot",
     "factorize NB columns.  Hence, the actual number of factorized",
     "columns is returned in KB.",
     "Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0"],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         The number of rows of A that have been factorized in",
       "         previous steps."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of columns to factorize."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns actually factorized."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, block A(OFFSET+1:M,1:KB) is the triangular",
       "         factor obtained and block A(1:OFFSET,1:N) has been",
       "         accordingly pivoted, but no factorized.",
       "         The rest of the matrix, block A(OFFSET+1:M,KB+1:N) has",
       "         been updated."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         JPVT(I) = K <==> Column K of the full matrix A has been",
       "         permuted into position I in AP."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (KB)",
       "         The scalar factors of the elementary reflectors."],
     "VN1"=>
      ["[in,out]",
       "         VN1 is DOUBLE PRECISION array, dimension (N)",
       "         The vector with the partial column norms."],
     "VN2"=>
      ["[in,out]",
       "         VN2 is DOUBLE PRECISION array, dimension (N)",
       "         The vector with the exact column norms."],
     "AUXV"=>
      ["[in,out]",
       "         AUXV is COMPLEX*16 array, dimension (NB)",
       "         Auxiliar vector."],
     "F"=>
      ["[in,out]",
       "         F is COMPLEX*16 array, dimension (LDF,NB)",
       "         Matrix F**H = L * Y**H * A."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the array F. LDF >= max(1,N)."]}},
 "claswp"=>
  {"summary"=>
    ["CLASWP performs a series of row interchanges on the matrix A.",
     "One row interchange is initiated for each of rows K1 through K2 of A."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the matrix of column dimension N to which the row",
       "         interchanges will be applied.",
       "         On exit, the permuted matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A."],
     "K1"=>
      ["[in]",
       "         K1 is INTEGER",
       "         The first element of IPIV for which a row interchange will",
       "         be done."],
     "K2"=>
      ["[in]",
       "         K2 is INTEGER",
       "         (K2-K1+1) is the number of elements of IPIV for which a row",
       "         interchange will be done."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (K1+(K2-K1)*abs(INCX))",
       "         The vector of pivot indices. Only the elements in positions",
       "         K1 through K1+(K2-K1)*INCX of IPIV are accessed.",
       "         IPIV(K) = L implies rows K and L are to be interchanged."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of IPIV.  If IPIV",
       "         is negative, the pivots are applied in reverse order."]}},
 "spbcon"=>
  {"summary"=>
    ["SPBCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric positive definite band matrix using the",
     "Cholesky factorization A = U**T*U or A = L*L**T computed by SPBTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor stored in AB;",
       "         = 'L':  Lower triangular factor stored in AB."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T of the band matrix A, stored in the",
       "         first KD+1 rows of the array.  The j-th column of U or L is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO ='U', AB(kd+1+i-j,j) = U(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO ='L', AB(1+i-j,j)    = L(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm (or infinity-norm) of the symmetric band matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgbbrd"=>
  {"summary"=>
    ["CGBBRD reduces a complex general m-by-n band matrix A to real upper",
     "bidiagonal form B by a unitary transformation: Q**H * A * P = B.",
     "The routine computes B, and optionally forms Q or P**H, or computes",
     "Q**H*C for a given matrix C."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         Specifies whether or not the matrices Q and P**H are to be",
       "         formed.",
       "         = 'N': do not form Q or P**H;",
       "         = 'Q': form Q only;",
       "         = 'P': form P**H only;",
       "         = 'B': form both."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NCC"=>
      ["[in]",
       "         NCC is INTEGER",
       "         The number of columns of the matrix C.  NCC >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals of the matrix A. KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals of the matrix A. KU >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the m-by-n band matrix A, stored in rows 1 to",
       "         KL+KU+1. The j-th column of A is stored in the j-th column of",
       "         the array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl).",
       "         On exit, A is overwritten by values generated during the",
       "         reduction."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array A. LDAB >= KL+KU+1."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (min(M,N)-1)",
       "         The superdiagonal elements of the bidiagonal matrix B."],
     "Q"=>
      ["[out]",
       "         Q is COMPLEX array, dimension (LDQ,M)",
       "         If VECT = 'Q' or 'B', the m-by-m unitary matrix Q.",
       "         If VECT = 'N' or 'P', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= max(1,M) if VECT = 'Q' or 'B'; LDQ >= 1 otherwise."],
     "PT"=>
      ["[out]",
       "         PT is COMPLEX array, dimension (LDPT,N)",
       "         If VECT = 'P' or 'B', the n-by-n unitary matrix P'.",
       "         If VECT = 'N' or 'Q', the array PT is not referenced."],
     "LDPT"=>
      ["[in]",
       "         LDPT is INTEGER",
       "         The leading dimension of the array PT.",
       "         LDPT >= max(1,N) if VECT = 'P' or 'B'; LDPT >= 1 otherwise."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,NCC)",
       "         On entry, an m-by-ncc matrix C.",
       "         On exit, C is overwritten by Q**H*C.",
       "         C is not referenced if NCC = 0."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.",
       "         LDC >= max(1,M) if NCC > 0; LDC >= 1 if NCC = 0."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (max(M,N))"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (max(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zgeqp3"=>
  {"summary"=>
    ["ZGEQP3 computes a QR factorization with column pivoting of a",
     "matrix A:  A*P = Q*R  using Level 3 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the upper triangle of the array contains the",
       "         min(M,N)-by-N upper trapezoidal matrix R; the elements below",
       "         the diagonal, together with the array TAU, represent the",
       "         unitary matrix Q as a product of min(M,N) elementary",
       "         reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(J).ne.0, the J-th column of A is permuted",
       "         to the front of A*P (a leading column); if JPVT(J)=0,",
       "         the J-th column of A is a free column.",
       "         On exit, if JPVT(J)=K, then the J-th column of A*P was the",
       "         the K-th column of A."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO=0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= N+1.",
       "         For optimal performance LWORK >= ( N+1 )*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit.",
       "         < 0: if INFO = -i, the i-th argument had an illegal value."]}},
 "zlaesy"=>
  {"summary"=>
    ["ZLAESY computes the eigendecomposition of a 2-by-2 symmetric matrix",
     "   ( ( A, B );( B, C ) )",
     "provided the norm of the matrix of eigenvectors is larger than",
     "some threshold value.",
     "RT1 is the eigenvalue of larger absolute value, and RT2 of",
     "smaller absolute value.  If the eigenvectors are computed, then",
     "on return ( CS1, SN1 ) is the unit eigenvector for RT1, hence",
     "[  CS1     SN1   ] . [ A  B ] . [ CS1    -SN1   ] = [ RT1  0  ]",
     "[ -SN1     CS1   ]   [ B  C ]   [ SN1     CS1   ]   [  0  RT2 ]"],
   "param"=>
    {"A"=>
      ["[in]",
       "         A is COMPLEX*16",
       "         The ( 1, 1 ) element of input matrix."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16",
       "         The ( 1, 2 ) element of input matrix.  The ( 2, 1 ) element",
       "         is also given by B, since the 2-by-2 matrix is symmetric."],
     "C"=>
      ["[in]",
       "         C is COMPLEX*16",
       "         The ( 2, 2 ) element of input matrix."],
     "RT1"=>
      ["[out]",
       "         RT1 is COMPLEX*16",
       "         The eigenvalue of larger modulus."],
     "RT2"=>
      ["[out]",
       "         RT2 is COMPLEX*16",
       "         The eigenvalue of smaller modulus."],
     "EVSCAL"=>
      ["[out]",
       "         EVSCAL is COMPLEX*16",
       "         The complex value by which the eigenvector matrix was scaled",
       "         to make it orthonormal.  If EVSCAL is zero, the eigenvectors",
       "         were not computed.  This means one of two things:  the 2-by-2",
       "         matrix could not be diagonalized, or the norm of the matrix",
       "         of eigenvectors before scaling was larger than the threshold",
       "         value THRESH (set below)."],
     "CS1"=>["[out]", "         CS1 is COMPLEX*16"],
     "SN1"=>
      ["[out]",
       "         SN1 is COMPLEX*16",
       "         If EVSCAL .NE. 0,  ( CS1, SN1 ) is the unit right eigenvector",
       "         for RT1."]}},
 "cunm2r"=>
  {"summary"=>
    ["CUNM2R overwrites the general complex m-by-n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**H* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**H if SIDE = 'R' and TRANS = 'C',",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by CGEQRF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left",
       "         = 'R': apply Q or Q**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGEQRF in the first k columns of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGEQRF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "chla_transtype"=>
  {"summary"=>
    ["This subroutine translates from a BLAST-specified integer constant to",
     "the character string specifying a transposition operation.",
     "CHLA_TRANSTYPE returns an CHARACTER*1.  If CHLA_TRANSTYPE is 'X',",
     "then input is not an integer indicating a transposition operator.",
     "Otherwise CHLA_TRANSTYPE returns the constant value corresponding to",
     "TRANS."],
   "param"=>nil},
 "slapy3"=>
  {"summary"=>
    ["SLAPY3 returns sqrt(x**2+y**2+z**2), taking care not to cause",
     "unnecessary overflow."],
   "param"=>
    {"X"=>["[in]", "         X is REAL"],
     "Y"=>["[in]", "         Y is REAL"],
     "Z"=>
      ["[in]",
       "         Z is REAL",
       "         X, Y and Z specify the values x, y and z."]}},
 "ssytri2x"=>
  {"summary"=>
    ["SSYTRI2X computes the inverse of a real symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "SSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the NNB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by SSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NNB structure of D",
       "         as determined by SSYTRF."],
     "WORK"=>
      ["[out]", "         WORK is REAL array, dimension (N+NNB+1,NNB+3)"],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "cungtr"=>
  {"summary"=>
    ["CUNGTR generates a complex unitary matrix Q which is defined as the",
     "product of n-1 elementary reflectors of order N, as returned by",
     "CHETRD:",
     "if UPLO = 'U', Q = H(n-1) . . . H(2) H(1),",
     "if UPLO = 'L', Q = H(1) H(2) . . . H(n-1)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U': Upper triangle of A contains elementary reflectors",
       "                from CHETRD;",
       "         = 'L': Lower triangle of A contains elementary reflectors",
       "                from CHETRD."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by CHETRD.",
       "         On exit, the N-by-N unitary matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= N."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CHETRD."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= N-1.",
       "         For optimum performance LWORK >= (N-1)*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ilauplo"=>
  {"summary"=>
    ["This subroutine translated from a character string specifying a",
     "upper- or lower-triangular matrix to the relevant BLAST-specified",
     "integer constant.",
     "ILAUPLO returns an INTEGER.  If ILAUPLO < 0, then the input is not",
     "a character indicating an upper- or lower-triangular matrix.",
     "Otherwise ILAUPLO returns the constant value corresponding to UPLO."],
   "param"=>nil},
 "zgbsvxx"=>
  {"summary"=>
    ["   ZGBSVXX uses the LU factorization to compute the solution to a",
     "   complex*16 system of linear equations  A * X = B,  where A is an",
     "   N-by-N matrix and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. ZGBSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   ZGBSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   ZGBSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what ZGBSVXX would itself produce."],
   "param"=>nil},
 "clahqr"=>
  {"summary"=>
    ["   CLAHQR is an auxiliary routine called by CHSEQR to update the",
     "   eigenvalues and Schur decomposition already computed by CHSEQR, by",
     "   dealing with the Hessenberg submatrix in rows and columns ILO to",
     "   IHI."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that H is already upper triangular in rows and",
       "         columns IHI+1:N, and that H(ILO,ILO-1) = 0 (unless ILO = 1).",
       "         CLAHQR works primarily with the Hessenberg submatrix in rows",
       "         and columns ILO to IHI, but applies transformations to all of",
       "         H if WANTT is .TRUE..",
       "         1 <= ILO <= max(1,IHI); IHI <= N."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX array, dimension (LDH,N)",
       "         On entry, the upper Hessenberg matrix H.",
       "         On exit, if INFO is zero and if WANTT is .TRUE., then H",
       "         is upper triangular in rows and columns ILO:IHI.  If INFO",
       "         is zero and if WANTT is .FALSE., then the contents of H",
       "         are unspecified on exit.  The output state of H in case",
       "         INF is positive is below under the description of INFO."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H. LDH >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX array, dimension (N)",
       "         The computed eigenvalues ILO to IHI are stored in the",
       "         corresponding elements of W. If WANTT is .TRUE., the",
       "         eigenvalues are stored in the same order as on the diagonal",
       "         of the Schur form returned in H, with W(i) = H(i,i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE..",
       "         1 <= ILOZ <= ILO; IHI <= IHIZ <= N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ,N)",
       "         If WANTZ is .TRUE., on entry Z must contain the current",
       "         matrix Z of transformations accumulated by CHSEQR, and on",
       "         exit Z has been updated; transformations are applied only to",
       "         the submatrix Z(ILOZ:IHIZ,ILO:IHI).",
       "         If WANTZ is .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          =   0: successful exit",
       "         .GT. 0: if INFO = i, CLAHQR failed to compute all the",
       "                 eigenvalues ILO to IHI in a total of 30 iterations",
       "                 per eigenvalue; elements i+1:ihi of W contain",
       "                 those eigenvalues which have been successfully",
       "                 computed.",
       "                 If INFO .GT. 0 and WANTT is .FALSE., then on exit,",
       "                 the remaining unconverged eigenvalues are the",
       "                 eigenvalues of the upper Hessenberg matrix",
       "                 rows and columns ILO thorugh INFO of the final,",
       "                 output value of H.",
       "                 If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "         (*)       (initial value of H)*U  = U*(final value of H)",
       "                 where U is an orthognal matrix.    The final",
       "                 value of H is upper Hessenberg and triangular in",
       "                 rows and columns INFO+1 through IHI.",
       "                 If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                     (final value of Z)  = (initial value of Z)*U",
       "                 where U is the orthogonal matrix in (*)",
       "                 (regardless of the value of WANTT.)"]}},
 "sgeqp3"=>
  {"summary"=>
    ["SGEQP3 computes a QR factorization with column pivoting of a",
     "matrix A:  A*P = Q*R  using Level 3 BLAS."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the upper triangle of the array contains the",
       "         min(M,N)-by-N upper trapezoidal matrix R; the elements below",
       "         the diagonal, together with the array TAU, represent the",
       "         orthogonal matrix Q as a product of min(M,N) elementary",
       "         reflectors."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(J).ne.0, the J-th column of A is permuted",
       "         to the front of A*P (a leading column); if JPVT(J)=0,",
       "         the J-th column of A is a free column.",
       "         On exit, if JPVT(J)=K, then the J-th column of A*P was the",
       "         the K-th column of A."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO=0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= 3*N+1.",
       "         For optimal performance LWORK >= 2*N+( N+1 )*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit.",
       "         < 0: if INFO = -i, the i-th argument had an illegal value."]}},
 "cla_wwaddw"=>
  {"summary"=>
    ["   CLA_WWADDW adds a vector W into a doubled-single vector (X, Y).",
     "   This works for all extant IBM's hex and binary floating point",
     "   arithmetics, but not for decimal."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "           The length of vectors X, Y, and W."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (N)",
       "           The first part of the doubled-single accumulation vector."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension (N)",
       "           The second part of the doubled-single accumulation vector."],
     "W"=>
      ["[in]",
       "         W is COMPLEX array, dimension (N)",
       "           The vector to be added."]}},
 "strsen"=>
  {"summary"=>
    ["STRSEN reorders the real Schur factorization of a real matrix",
     "A = Q*T*Q**T, so that a selected cluster of eigenvalues appears in",
     "the leading diagonal blocks of the upper quasi-triangular matrix T,",
     "and the leading columns of Q form an orthonormal basis of the",
     "corresponding right invariant subspace.",
     "Optionally the routine computes the reciprocal condition numbers of",
     "the cluster of eigenvalues and/or the invariant subspace.",
     "T must be in Schur canonical form (as returned by SHSEQR), that is,",
     "block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each",
     "2-by-2 diagonal block has its diagonal elements equal and its",
     "off-diagonal elements of opposite sign."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for the",
       "         cluster of eigenvalues (S) or the invariant subspace (SEP):",
       "         = 'N': none;",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for invariant subspace only (SEP);",
       "         = 'B': for both eigenvalues and invariant subspace (S and",
       "                SEP)."],
     "COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'V': update the matrix Q of Schur vectors;",
       "         = 'N': do not update Q."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         SELECT specifies the eigenvalues in the selected cluster. To",
       "         select a real eigenvalue w(j), SELECT(j) must be set to",
       "         .TRUE.. To select a complex conjugate pair of eigenvalues",
       "         w(j) and w(j+1), corresponding to a 2-by-2 diagonal block,",
       "         either SELECT(j) or SELECT(j+1) or both must be set to",
       "         .TRUE.; a complex conjugate pair of eigenvalues must be",
       "         either both included in the cluster or both excluded."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in,out]",
       "         T is REAL array, dimension (LDT,N)",
       "         On entry, the upper quasi-triangular matrix T, in Schur",
       "         canonical form.",
       "         On exit, T is overwritten by the reordered matrix T, again in",
       "         Schur canonical form, with the selected eigenvalues in the",
       "         leading diagonal blocks."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "         On entry, if COMPQ = 'V', the matrix Q of Schur vectors.",
       "         On exit, if COMPQ = 'V', Q has been postmultiplied by the",
       "         orthogonal transformation matrix which reorders T; the",
       "         leading M columns of Q form an orthonormal basis for the",
       "         specified invariant subspace.",
       "         If COMPQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= 1; and if COMPQ = 'V', LDQ >= N."],
     "WR"=>["[out]", "         WR is REAL array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is REAL array, dimension (N)",
       "         The real and imaginary parts, respectively, of the reordered",
       "         eigenvalues of T. The eigenvalues are stored in the same",
       "         order as on the diagonal of T, with WR(i) = T(i,i) and, if",
       "         T(i:i+1,i:i+1) is a 2-by-2 diagonal block, WI(i) > 0 and",
       "         WI(i+1) = -WI(i). Note that if a complex eigenvalue is",
       "         sufficiently ill-conditioned, then its value may differ",
       "         significantly from its value before reordering."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The dimension of the specified invariant subspace.",
       "         0 < = M <= N."],
     "S"=>
      ["[out]",
       "         S is REAL",
       "         If JOB = 'E' or 'B', S is a lower bound on the reciprocal",
       "         condition number for the selected cluster of eigenvalues.",
       "         S cannot underestimate the true reciprocal condition number",
       "         by more than a factor of sqrt(N). If M = 0 or N, S = 1.",
       "         If JOB = 'N' or 'V', S is not referenced."],
     "SEP"=>
      ["[out]",
       "         SEP is REAL",
       "         If JOB = 'V' or 'B', SEP is the estimated reciprocal",
       "         condition number of the specified invariant subspace. If",
       "         M = 0 or N, SEP = norm(T).",
       "         If JOB = 'N' or 'E', SEP is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If JOB = 'N', LWORK >= max(1,N);",
       "         if JOB = 'E', LWORK >= max(1,M*(N-M));",
       "         if JOB = 'V' or 'B', LWORK >= max(1,2*M*(N-M)).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOB = 'N' or 'E', LIWORK >= 1;",
       "         if JOB = 'V' or 'B', LIWORK >= max(1,M*(N-M)).",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         = 1: reordering of T failed because some eigenvalues are too",
       "              close to separate (the problem is very ill-conditioned);",
       "              T may have been partially reordered, and WR and WI",
       "              contain the eigenvalues in the same order as in T; S and",
       "              SEP (if requested) are set to zero."]}},
 "spptrs"=>
  {"summary"=>
    ["SPPTRS solves a system of linear equations A*X = B with a symmetric",
     "positive definite matrix A in packed storage using the Cholesky",
     "factorization A = U**T*U or A = L*L**T computed by SPPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**T*U or A = L*L**T, packed columnwise in a linear",
       "         array.  The j-th column of U or L is stored in the array AP",
       "         as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clarfg"=>
  {"summary"=>
    ["CLARFG generates a complex elementary reflector H of order n, such",
     "that",
     "      H**H * ( alpha ) = ( beta ),   H**H * H = I.",
     "             (   x   )   (   0  )",
     "where alpha and beta are scalars, with beta real, and x is an",
     "(n-1)-element complex vector. H is represented in the form",
     "      H = I - tau * ( 1 ) * ( 1 v**H ) ,",
     "                    ( v )",
     "where tau is a complex scalar and v is a complex (n-1)-element",
     "vector. Note that H is not hermitian.",
     "If the elements of x are all zero and alpha is real, then tau = 0",
     "and H is taken to be the unit matrix.",
     "Otherwise  1 <= real(tau) <= 2  and  abs(tau-1) <= 1 ."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the elementary reflector."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is COMPLEX",
       "         On entry, the value alpha.",
       "         On exit, it is overwritten with the value beta."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension",
       "                        (1+(N-2)*abs(INCX))",
       "         On entry, the vector x.",
       "         On exit, it is overwritten with the vector v."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "TAU"=>["[out]", "         TAU is COMPLEX", "         The value tau."]}},
 "dlarf"=>
  {"summary"=>
    ["DLARF applies a real elementary reflector H to a real m by n matrix",
     "C, from either the left or the right. H is represented in the form",
     "      H = I - tau * v * v**T",
     "where tau is a real scalar and v is a real vector.",
     "If tau = 0, then H is taken to be the unit matrix."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension",
       "                    (1 + (M-1)*abs(INCV)) if SIDE = 'L'",
       "                 or (1 + (N-1)*abs(INCV)) if SIDE = 'R'",
       "         The vector v in the representation of H. V is not used if",
       "         TAU = 0."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between elements of v. INCV <> 0."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension",
       "                        (N) if SIDE = 'L'",
       "                     or (M) if SIDE = 'R'"]}},
 "sposvxx"=>
  {"summary"=>
    ["   SPOSVXX uses the Cholesky factorization A = U**T*U or A = L*L**T",
     "   to compute the solution to a real system of linear equations",
     "   A * X = B, where A is an N-by-N symmetric positive definite matrix",
     "   and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. SPOSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   SPOSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   SPOSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what SPOSVXX would itself produce."],
   "param"=>nil},
 "zlarfy"=>
  {"summary"=>
    ["ZLARFY applies an elementary reflector, or Householder matrix, H,",
     "to an n x n Hermitian matrix C, from both the left and the right.",
     "H is represented in the form",
     "   H = I - tau * v * v'",
     "where  tau  is a scalar and  v  is a vector.",
     "If  tau  is  zero, then  H  is taken to be the unit matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix C is stored.",
       "         = 'U':  Upper triangle",
       "         = 'L':  Lower triangle"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows and columns of the matrix C.  N >= 0."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension",
       "                 (1 + (N-1)*abs(INCV))",
       "         The vector v as described above."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between successive elements of v.  INCV must",
       "         not be zero."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16",
       "         The value tau as described above."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC, N)",
       "         On entry, the matrix C.",
       "         On exit, C is overwritten by H * C * H'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.  LDC >= max( 1, N )."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"]}},
 "dsbtrd"=>
  {"summary"=>
    ["DSBTRD reduces a real symmetric band matrix A to symmetric",
     "tridiagonal form T by an orthogonal similarity transformation:",
     "Q**T * A * Q = T."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  do not form Q;",
       "         = 'V':  form Q;",
       "         = 'U':  update a matrix X, by forming X*Q."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, the diagonal elements of AB are overwritten by the",
       "         diagonal elements of the tridiagonal matrix T; if KD > 0, the",
       "         elements on the first superdiagonal (if UPLO = 'U') or the",
       "         first subdiagonal (if UPLO = 'L') are overwritten by the",
       "         off-diagonal elements of T; the rest of AB is overwritten by",
       "         values generated during the reduction."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = T(i,i+1) if UPLO = 'U'; E(i) = T(i+1,i) if UPLO = 'L'."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         On entry, if VECT = 'U', then Q must contain an N-by-N",
       "         matrix X; if VECT = 'N' or 'V', then Q need not be set.",
       "         On exit:",
       "         if VECT = 'V', Q contains the N-by-N orthogonal matrix Q;",
       "         if VECT = 'U', Q contains the product X*Q;",
       "         if VECT = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= 1, and LDQ >= N if VECT = 'V' or 'U'."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ctrti2"=>
  {"summary"=>
    ["CTRTI2 computes the inverse of a complex upper or lower triangular",
     "matrix.",
     "This is the Level 2 BLAS version of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading n by n upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced.  If DIAG = 'U', the",
       "         diagonal elements of A are also not referenced and are",
       "         assumed to be 1.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "zhetrs_aa"=>
  {"summary"=>
    ["ZHETRS_AA solves a system of linear equations A*X = B with a complex",
     "hermitian matrix A using the factorization A = U*T*U**H or",
     "A = L*T*L**T computed by ZHETRF_AA."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*T*U**H;",
       "         = 'L':  Lower triangular, form is A = L*T*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         Details of factors computed by ZHETRF_AA."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges as computed by ZHETRF_AA."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[in]", "         WORK is DOUBLE array, dimension (MAX(1,LWORK))"],
     "LWORK"=>["[in]", "         LWORK is INTEGER, LWORK >= MAX(1,3*N-2)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slasv2"=>
  {"summary"=>
    ["SLASV2 computes the singular value decomposition of a 2-by-2",
     "triangular matrix",
     "   [  F   G  ]",
     "   [  0   H  ].",
     "On return, abs(SSMAX) is the larger singular value, abs(SSMIN) is the",
     "smaller singular value, and (CSL,SNL) and (CSR,SNR) are the left and",
     "right singular vectors for abs(SSMAX), giving the decomposition",
     "   [ CSL  SNL ] [  F   G  ] [ CSR -SNR ]  =  [ SSMAX   0   ]",
     "   [-SNL  CSL ] [  0   H  ] [ SNR  CSR ]     [  0    SSMIN ]."],
   "param"=>
    {"F"=>
      ["[in]",
       "         F is REAL",
       "         The (1,1) element of the 2-by-2 matrix."],
     "G"=>
      ["[in]",
       "         G is REAL",
       "         The (1,2) element of the 2-by-2 matrix."],
     "H"=>
      ["[in]",
       "         H is REAL",
       "         The (2,2) element of the 2-by-2 matrix."],
     "SSMIN"=>
      ["[out]",
       "         SSMIN is REAL",
       "         abs(SSMIN) is the smaller singular value."],
     "SSMAX"=>
      ["[out]",
       "         SSMAX is REAL",
       "         abs(SSMAX) is the larger singular value."],
     "SNL"=>["[out]", "         SNL is REAL"],
     "CSL"=>
      ["[out]",
       "         CSL is REAL",
       "         The vector (CSL, SNL) is a unit left singular vector for the",
       "         singular value abs(SSMAX)."],
     "SNR"=>["[out]", "         SNR is REAL"],
     "CSR"=>
      ["[out]",
       "         CSR is REAL",
       "         The vector (CSR, SNR) is a unit right singular vector for the",
       "         singular value abs(SSMAX)."]}},
 "zhptrf"=>
  {"summary"=>
    ["ZHPTRF computes the factorization of a complex Hermitian packed",
     "matrix A using the Bunch-Kaufman diagonal pivoting method:",
     "   A = U*D*U**H  or  A = L*D*L**H",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is Hermitian and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L, stored as a packed triangular",
       "         matrix overwriting A (see below for further details)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "sgeqrt"=>
  {"summary"=>
    ["SGEQRT computes a blocked QR factorization of a real M-by-N matrix A",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.  MIN(M,N) >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if M >= N); the elements below the diagonal",
       "         are the columns of V."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,MIN(M,N))",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (NB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cuncsd2by1"=>
  {"summary"=>[],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is computed;",
       "         otherwise:  U1 is not computed."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is computed;",
       "         otherwise:  U2 is not computed."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is computed;",
       "         otherwise:  V1T is not computed."],
     "M"=>
      ["[in]", "         M is INTEGER", "         The number of rows in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX array, dimension (LDX11,Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. LDX11 >= MAX(1,P)."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX array, dimension (LDX21,Q)",
       "         On entry, part of the unitary matrix whose CSD is desired."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "         The leading dimension of X21. LDX21 >= MAX(1,M-P)."],
     "THETA"=>
      ["[out]",
       "         THETA is REAL array, dimension (R), in which R =",
       "         MIN(P,M-P,Q,M-Q).",
       "         C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and",
       "         S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) )."],
     "U1"=>
      ["[out]",
       "         U1 is COMPLEX array, dimension (P)",
       "         If JOBU1 = 'Y', U1 contains the P-by-P unitary matrix U1."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of U1. If JOBU1 = 'Y', LDU1 >=",
       "         MAX(1,P)."],
     "U2"=>
      ["[out]",
       "         U2 is COMPLEX array, dimension (M-P)",
       "         If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) unitary",
       "         matrix U2."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of U2. If JOBU2 = 'Y', LDU2 >=",
       "         MAX(1,M-P)."],
     "V1T"=>
      ["[out]",
       "         V1T is COMPLEX array, dimension (Q)",
       "         If JOBV1T = 'Y', V1T contains the Q-by-Q matrix unitary",
       "         matrix V1**T."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >=",
       "         MAX(1,Q)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.",
       "         If INFO > 0 on exit, RWORK(2:R) contains the values PHI(1),",
       "         ..., PHI(R-1) that, together with THETA(1), ..., THETA(R),",
       "         define the matrix in intermediate bidiagonal-block form",
       "         remaining after nonconvergence. INFO specifies the number",
       "         of nonzero PHI's."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If LRWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the RWORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LRWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  CBBCSD did not converge. See the description of WORK",
       "               above for details."]}},
 "strevc3"=>
  {"summary"=>
    ["STREVC3 computes some or all of the right and/or left eigenvectors of",
     "a real upper quasi-triangular matrix T.",
     "Matrices of this type are produced by the Schur factorization of",
     "a real general matrix:  A = Q*T*Q**T, as computed by SHSEQR.",
     "The right eigenvector x and the left eigenvector y of T corresponding",
     "to an eigenvalue w are defined by:",
     "   T*x = w*x,     (y**H)*T = w*(y**H)",
     "where y**H denotes the conjugate transpose of y.",
     "The eigenvalues are not input to this routine, but are read directly",
     "from the diagonal blocks of T.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an",
     "input matrix. If Q is the orthogonal factor that reduces a matrix",
     "A to Schur form T, then Q*X and Q*Y are the matrices of right and",
     "left eigenvectors of A.",
     "This uses a Level 3 BLAS version of the back transformation."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  compute right eigenvectors only;",
       "         = 'L':  compute left eigenvectors only;",
       "         = 'B':  compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A':  compute all right and/or left eigenvectors;",
       "         = 'B':  compute all right and/or left eigenvectors,",
       "                 backtransformed by the matrices in VR and/or VL;",
       "         = 'S':  compute selected right and/or left eigenvectors,",
       "                 as indicated by the logical array SELECT."],
     "SELECT"=>
      ["[in,out]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenvectors to be",
       "         computed.",
       "         If w(j) is a real eigenvalue, the corresponding real",
       "         eigenvector is computed if SELECT(j) is .TRUE..",
       "         If w(j) and w(j+1) are the real and imaginary parts of a",
       "         complex eigenvalue, the corresponding complex eigenvector is",
       "         computed if either SELECT(j) or SELECT(j+1) is .TRUE., and",
       "         on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is set to",
       "         .FALSE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (LDT,N)",
       "         The upper quasi-triangular matrix T in Schur canonical form."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is REAL array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the orthogonal matrix Q",
       "         of Schur vectors returned by SHSEQR).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VL, in the same order as their",
       "                          eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part, and the second the imaginary part.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= 1, and if SIDE = 'L' or 'B', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is REAL array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Q (usually the orthogonal matrix Q",
       "         of Schur vectors returned by SHSEQR).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*X;",
       "         if HOWMNY = 'S', the right eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VR, in the same order as their",
       "                          eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part and the second the imaginary part.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= 1, and if SIDE = 'R' or 'B', LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.",
       "         If HOWMNY = 'A' or 'B', M is set to N.",
       "         Each selected real eigenvector occupies one column and each",
       "         selected complex eigenvector occupies two columns."],
     "WORK"=>
      ["[out]", "         WORK is REAL array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of array WORK. LWORK >= max(1,3*N).",
       "         For optimum performance, LWORK >= N + 2*N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sladiv"=>
  {"summary"=>
    ["SLADIV performs complex division in  real arithmetic",
     "                      a + i*b",
     "           p + i*q = ---------",
     "                      c + i*d",
     "The algorithm is due to Michael Baudin and Robert L. Smith",
     "and can be found in the paper",
     "\"A Robust Complex Division in Scilab\""],
   "param"=>
    {"A"=>["[in]", "         A is REAL"],
     "B"=>["[in]", "         B is REAL"],
     "C"=>["[in]", "         C is REAL"],
     "D"=>
      ["[in]",
       "         D is REAL",
       "         The scalars a, b, c, and d in the above expression."],
     "P"=>["[out]", "         P is REAL"],
     "Q"=>
      ["[out]",
       "         Q is REAL",
       "         The scalars p and q in the above expression."]}},
 "zgeesx"=>
  {"summary"=>
    ["ZGEESX computes for an N-by-N complex nonsymmetric matrix A, the",
     "eigenvalues, the Schur form T, and, optionally, the matrix of Schur",
     "vectors Z.  This gives the Schur factorization A = Z*T*(Z**H).",
     "Optionally, it also orders the eigenvalues on the diagonal of the",
     "Schur form so that selected eigenvalues are at the top left;",
     "computes a reciprocal condition number for the average of the",
     "selected eigenvalues (RCONDE); and computes a reciprocal condition",
     "number for the right invariant subspace corresponding to the",
     "selected eigenvalues (RCONDV).  The leading columns of Z form an",
     "orthonormal basis for this invariant subspace.",
     "For further explanation of the reciprocal condition numbers RCONDE",
     "and RCONDV, see Section 4.10 of the LAPACK Users' Guide (where",
     "these quantities are called s and sep respectively).",
     "A complex matrix is in Schur form if it is upper triangular."],
   "param"=>
    {"JOBVS"=>
      ["[in]",
       "         JOBVS is CHARACTER*1",
       "         = 'N': Schur vectors are not computed;",
       "         = 'V': Schur vectors are computed."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the Schur form.",
       "         = 'N': Eigenvalues are not ordered;",
       "         = 'S': Eigenvalues are ordered (see SELECT)."],
     "SELECT"=>
      ["[in]",
       "         SELECT is a LOGICAL FUNCTION of one COMPLEX*16 argument",
       "         SELECT must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'S', SELECT is used to select eigenvalues to order",
       "         to the top left of the Schur form.",
       "         If SORT = 'N', SELECT is not referenced.",
       "         An eigenvalue W(j) is selected if SELECT(W(j)) is true."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': None are computed;",
       "         = 'E': Computed for average of selected eigenvalues only;",
       "         = 'V': Computed for selected right invariant subspace only;",
       "         = 'B': Computed for both.",
       "         If SENSE = 'E', 'V' or 'B', SORT must equal 'S'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A is overwritten by its Schur form T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues for which",
       "                        SELECT is true."],
     "W"=>
      ["[out]",
       "         W is COMPLEX*16 array, dimension (N)",
       "         W contains the computed eigenvalues, in the same order",
       "         that they appear on the diagonal of the output Schur form T."],
     "VS"=>
      ["[out]",
       "         VS is COMPLEX*16 array, dimension (LDVS,N)",
       "         If JOBVS = 'V', VS contains the unitary matrix Z of Schur",
       "         vectors.",
       "         If JOBVS = 'N', VS is not referenced."],
     "LDVS"=>
      ["[in]",
       "         LDVS is INTEGER",
       "         The leading dimension of the array VS.  LDVS >= 1, and if",
       "         JOBVS = 'V', LDVS >= N."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is DOUBLE PRECISION",
       "         If SENSE = 'E' or 'B', RCONDE contains the reciprocal",
       "         condition number for the average of the selected eigenvalues.",
       "         Not referenced if SENSE = 'N' or 'V'."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is DOUBLE PRECISION",
       "         If SENSE = 'V' or 'B', RCONDV contains the reciprocal",
       "         condition number for the selected right invariant subspace.",
       "         Not referenced if SENSE = 'N' or 'E'."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,2*N).",
       "         Also, if SENSE = 'E' or 'V' or 'B', LWORK >= 2*SDIM*(N-SDIM),",
       "         where SDIM is the number of selected eigenvalues computed by",
       "         this routine.  Note that 2*SDIM*(N-SDIM) <= N*N/2. Note also",
       "         that an error is only returned if LWORK < max(1,2*N), but if",
       "         SENSE = 'E' or 'V' or 'B' this may not be large enough.",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates upper bound on the optimal size of the",
       "         array WORK, returns this value as the first entry of the WORK",
       "         array, and no error message related to LWORK is issued by",
       "         XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value.",
       "         > 0: if INFO = i, and i is",
       "            <= N: the QR algorithm failed to compute all the",
       "                  eigenvalues; elements 1:ILO-1 and i+1:N of W",
       "                  contain those eigenvalues which have converged; if",
       "                  JOBVS = 'V', VS contains the transformation which",
       "                  reduces A to its partially converged Schur form.",
       "            = N+1: the eigenvalues could not be reordered because some",
       "                  eigenvalues were too close to separate (the problem",
       "                  is very ill-conditioned);",
       "            = N+2: after reordering, roundoff changed values of some",
       "                  complex eigenvalues so that leading eigenvalues in",
       "                  the Schur form no longer satisfy SELECT=.TRUE.  This",
       "                  could also be caused by underflow due to scaling."]}},
 "slarrb"=>
  {"summary"=>
    ["Given the relatively robust representation(RRR) L D L^T, SLARRB",
     "does \"limited\" bisection to refine the eigenvalues of L D L^T,",
     "W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial",
     "guesses for these eigenvalues are input in W, the corresponding estimate",
     "of the error in these guesses and their gaps are input in WERR",
     "and WGAP, respectively. During bisection, intervals",
     "[left, right] are maintained by storing their mid-points and",
     "semi-widths in the arrays W and WERR respectively."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The N diagonal elements of the diagonal matrix D."],
     "LLD"=>
      ["[in]",
       "         LLD is REAL array, dimension (N-1)",
       "         The (N-1) elements L(i)*L(i)*D(i)."],
     "IFIRST"=>
      ["[in]",
       "         IFIRST is INTEGER",
       "         The index of the first eigenvalue to be computed."],
     "ILAST"=>
      ["[in]",
       "         ILAST is INTEGER",
       "         The index of the last eigenvalue to be computed."],
     "RTOL1"=>["[in]", "         RTOL1 is REAL"],
     "RTOL2"=>
      ["[in]",
       "         RTOL2 is REAL",
       "         Tolerance for the convergence of the bisection intervals.",
       "         An interval [LEFT,RIGHT] has converged if",
       "         RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )",
       "         where GAP is the (estimated) distance to the nearest",
       "         eigenvalue."],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         Offset for the arrays W, WGAP and WERR, i.e., the IFIRST-OFFSET",
       "         through ILAST-OFFSET elements of these arrays are to be used."],
     "W"=>
      ["[in,out]",
       "         W is REAL array, dimension (N)",
       "         On input, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ) are",
       "         estimates of the eigenvalues of L D L^T indexed IFIRST throug",
       "         ILAST.",
       "         On output, these estimates are refined."],
     "WGAP"=>
      ["[in,out]",
       "         WGAP is REAL array, dimension (N-1)",
       "         On input, the (estimated) gaps between consecutive",
       "         eigenvalues of L D L^T, i.e., WGAP(I-OFFSET) is the gap between",
       "         eigenvalues I and I+1. Note that if IFIRST.EQ.ILAST",
       "         then WGAP(IFIRST-OFFSET) must be set to ZERO.",
       "         On output, these gaps are refined."],
     "WERR"=>
      ["[in,out]",
       "         WERR is REAL array, dimension (N)",
       "         On input, WERR( IFIRST-OFFSET ) through WERR( ILAST-OFFSET ) are",
       "         the errors in the estimates of the corresponding elements in W.",
       "         On output, these errors are refined."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (2*N)",
       "         Workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (2*N)",
       "         Workspace."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "         The minimum pivot in the Sturm sequence."],
     "SPDIAM"=>
      ["[in]",
       "         SPDIAM is REAL",
       "         The spectral diameter of the matrix."],
     "TWIST"=>
      ["[in]",
       "         TWIST is INTEGER",
       "         The twist index for the twisted factorization that is used",
       "         for the negcount.",
       "         TWIST = N: Compute negcount from L D L^T - LAMBDA I = L+ D+ L+^T",
       "         TWIST = 1: Compute negcount from L D L^T - LAMBDA I = U- D- U-^T",
       "         TWIST = R: Compute negcount from L D L^T - LAMBDA I = N(r) D(r) N(r)"],
     "INFO"=>["[out]", "         INFO is INTEGER", "         Error flag."]}},
 "ilaslc"=>
  {"summary"=>["ILASLC scans A for its last non-zero column."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."]}},
 "cgeev"=>
  {"summary"=>
    ["CGEEV computes for an N-by-N complex nonsymmetric matrix A, the",
     "eigenvalues and, optionally, the left and/or right eigenvectors.",
     "The right eigenvector v(j) of A satisfies",
     "                 A * v(j) = lambda(j) * v(j)",
     "where lambda(j) is its eigenvalue.",
     "The left eigenvector u(j) of A satisfies",
     "              u(j)**H * A = lambda(j) * u(j)**H",
     "where u(j)**H denotes the conjugate transpose of u(j).",
     "The computed eigenvectors are normalized to have Euclidean norm",
     "equal to 1 and largest component real."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N': left eigenvectors of A are not computed;",
       "         = 'V': left eigenvectors of are computed."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N': right eigenvectors of A are not computed;",
       "         = 'V': right eigenvectors of A are computed."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the N-by-N matrix A.",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX array, dimension (N)",
       "         W contains the computed eigenvalues."],
     "VL"=>
      ["[out]",
       "         VL is COMPLEX array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order",
       "         as their eigenvalues.",
       "         If JOBVL = 'N', VL is not referenced.",
       "         u(j) = VL(:,j), the j-th column of VL."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1; if",
       "         JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is COMPLEX array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order",
       "         as their eigenvalues.",
       "         If JOBVR = 'N', VR is not referenced.",
       "         v(j) = VR(:,j), the j-th column of VR."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1; if",
       "         JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,2*N).",
       "         For good performance, LWORK must generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the QR algorithm failed to compute all the",
       "               eigenvalues, and no eigenvectors have been computed;",
       "               elements and i+1:N of W contain eigenvalues which have",
       "               converged."]}},
 "slaneg"=>
  {"summary"=>
    ["SLANEG computes the Sturm count, the number of negative pivots",
     "encountered while factoring tridiagonal T - sigma I = L D L^T.",
     "This implementation works directly on the factors without forming",
     "the tridiagonal matrix T.  The Sturm count is also the number of",
     "eigenvalues of T less than sigma.",
     "This routine is called from SLARRB.",
     "The current routine does not use the PIVMIN parameter but rather",
     "requires IEEE-754 propagation of Infinities and NaNs.  This",
     "routine also has no input range restrictions but does require",
     "default exception handling such that x/0 produces Inf when x is",
     "non-zero, and Inf/Inf produces NaN.  For more information, see:",
     "  Marques, Riedy, and Voemel, \"Benefits of IEEE-754 Features in",
     "  Modern Symmetric Tridiagonal Eigensolvers,\" SIAM Journal on",
     "  Scientific Computing, v28, n5, 2006.  DOI 10.1137/050641624",
     "  (Tech report version in LAWN 172 with the same title.)"],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The N diagonal elements of the diagonal matrix D."],
     "LLD"=>
      ["[in]",
       "         LLD is REAL array, dimension (N-1)",
       "         The (N-1) elements L(i)*L(i)*D(i)."],
     "SIGMA"=>
      ["[in]",
       "         SIGMA is REAL",
       "         Shift amount in T - sigma I = L D L^T."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "         The minimum pivot in the Sturm sequence.  May be used",
       "         when zero pivots are encountered on non-IEEE-754",
       "         architectures."],
     "R"=>
      ["[in]",
       "         R is INTEGER",
       "         The twist index for the twisted factorization that is used",
       "         for the negcount."]}},
 "dsytrs"=>
  {"summary"=>
    ["DSYTRS solves a system of linear equations A*X = B with a real",
     "symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by DSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by DSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlasq4"=>
  {"summary"=>
    ["DLASQ4 computes an approximation TAU to the smallest eigenvalue",
     "using values of d from the previous transform."],
   "param"=>
    {"I0"=>["[in]", "         I0 is INTEGER", "       First index."],
     "N0"=>["[in]", "         N0 is INTEGER", "       Last index."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension ( 4*N0 )",
       "       Z holds the qd array."],
     "PP"=>
      ["[in]",
       "         PP is INTEGER",
       "       PP=0 for ping, PP=1 for pong."],
     "N0IN"=>
      ["[in]",
       "         N0IN is INTEGER",
       "       The value of N0 at start of EIGTEST."],
     "DMIN"=>
      ["[in]",
       "         DMIN is DOUBLE PRECISION",
       "       Minimum value of d."],
     "DMIN1"=>
      ["[in]",
       "         DMIN1 is DOUBLE PRECISION",
       "       Minimum value of d, excluding D( N0 )."],
     "DMIN2"=>
      ["[in]",
       "         DMIN2 is DOUBLE PRECISION",
       "       Minimum value of d, excluding D( N0 ) and D( N0-1 )."],
     "DN"=>["[in]", "         DN is DOUBLE PRECISION", "       d(N)"],
     "DN1"=>["[in]", "         DN1 is DOUBLE PRECISION", "       d(N-1)"],
     "DN2"=>["[in]", "         DN2 is DOUBLE PRECISION", "       d(N-2)"],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION",
       "       This is the shift."],
     "TTYPE"=>["[out]", "         TTYPE is INTEGER", "       Shift type."],
     "G"=>
      ["[in,out]",
       "         G is DOUBLE PRECISION",
       "       G is passed as an argument in order to save its value between",
       "       calls to DLASQ4."]}},
 "dsbgvd"=>
  {"summary"=>
    ["DSBGVD computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite banded eigenproblem, of the",
     "form A*x=(lambda)*B*x.  Here A and B are assumed to be symmetric and",
     "banded, and B is also positive definite.  If eigenvectors are",
     "desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is DOUBLE PRECISION array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(ka+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**T*S, as returned by DPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i).  The eigenvectors are",
       "         normalized so Z**T*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK >= 1.",
       "         If JOBZ = 'N' and N > 1, LWORK >= 2*N.",
       "         If JOBZ = 'V' and N > 1, LWORK >= 1 + 5*N + 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if LIWORK > 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK >= 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK >= 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is:",
       "            <= N:  the algorithm failed to converge:",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then DPBSTF",
       "                   returned INFO = i: B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "cgehd2"=>
  {"summary"=>
    ["CGEHD2 reduces a complex general matrix A to upper Hessenberg form H",
     "by a unitary similarity transformation:  Q**H * A * Q = H ."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that A is already upper triangular in rows",
       "         and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "         set by a previous call to CGEBAL; otherwise they should be",
       "         set to 1 and N respectively. See Further Details.",
       "         1 <= ILO <= IHI <= max(1,N)."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the n by n general matrix to be reduced.",
       "         On exit, the upper triangle and the first subdiagonal of A",
       "         are overwritten with the upper Hessenberg matrix H, and the",
       "         elements below the first subdiagonal, with the array TAU,",
       "         represent the unitary matrix Q as a product of elementary",
       "         reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zgetsls"=>
  {"summary"=>
    ["ZGETSLS solves overdetermined or underdetermined complex linear systems",
     "involving an M-by-N matrix A, using a tall skinny QR or short wide LQ",
     "factorization of A.  It is assumed that A has full rank.",
     "The following options are provided:",
     "1. If TRANS = 'N' and m >= n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A*X ||.",
     "2. If TRANS = 'N' and m < n:  find the minimum norm solution of",
     "   an underdetermined system A * X = B.",
     "3. If TRANS = 'C' and m >= n:  find the minimum norm solution of",
     "   an undetermined system A**T * X = B.",
     "4. If TRANS = 'C' and m < n:  find the least squares solution of",
     "   an overdetermined system, i.e., solve the least squares problem",
     "                minimize || B - A**T * X ||.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': the linear system involves A;",
       "         = 'C': the linear system involves A**C."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of the matrices B and X. NRHS >=0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         A is overwritten by details of its QR or LQ",
       "         factorization as returned by ZGEQR or ZGELQ."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the matrix B of right hand side vectors, stored",
       "         columnwise; B is M-by-NRHS if TRANS = 'N', or N-by-NRHS",
       "         if TRANS = 'C'.",
       "         On exit, if INFO = 0, B is overwritten by the solution",
       "         vectors, stored columnwise:",
       "         if TRANS = 'N' and m >= n, rows 1 to n of B contain the least",
       "         squares solution vectors.",
       "         if TRANS = 'N' and m < n, rows 1 to N of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'C' and m >= n, rows 1 to M of B contain the",
       "         minimum norm solution vectors;",
       "         if TRANS = 'C' and m < n, rows 1 to M of B contain the",
       "         least squares solution vectors."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= MAX(1,M,N)."],
     "WORK"=>
      ["[out]",
       "         (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO =  i, the i-th diagonal element of the",
       "               triangular factor of A is zero, so that A does not have",
       "               full rank; the least squares solution could not be",
       "               computed."]}},
 "ztrsyl"=>
  {"summary"=>
    ["ZTRSYL solves the complex Sylvester matrix equation:",
     "   op(A)*X + X*op(B) = scale*C or",
     "   op(A)*X - X*op(B) = scale*C,",
     "where op(A) = A or A**H, and A and B are both upper triangular. A is",
     "M-by-M and B is N-by-N; the right hand side C and the solution X are",
     "M-by-N; and scale is an output scale factor, set <= 1 to avoid",
     "overflow in X."],
   "param"=>
    {"TRANA"=>
      ["[in]",
       "         TRANA is CHARACTER*1",
       "         Specifies the option op(A):",
       "         = 'N': op(A) = A    (No transpose)",
       "         = 'C': op(A) = A**H (Conjugate transpose)"],
     "TRANB"=>
      ["[in]",
       "         TRANB is CHARACTER*1",
       "         Specifies the option op(B):",
       "         = 'N': op(B) = B    (No transpose)",
       "         = 'C': op(B) = B**H (Conjugate transpose)"],
     "ISGN"=>
      ["[in]",
       "         ISGN is INTEGER",
       "         Specifies the sign in the equation:",
       "         = +1: solve op(A)*X + X*op(B) = scale*C",
       "         = -1: solve op(A)*X - X*op(B) = scale*C"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The order of the matrix A, and the number of rows in the",
       "         matrices X and C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix B, and the number of columns in the",
       "         matrices X and C. N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,M)",
       "         The upper triangular matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         The upper triangular matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N right hand side matrix C.",
       "         On exit, C is overwritten by the solution matrix X."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)"],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         The scale factor, scale, set <= 1 to avoid overflow in X."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         = 1: A and B have common or very close eigenvalues; perturbed",
       "              values were used to solve the equation (but the matrices",
       "              A and B are unchanged)."]}},
 "dspsvx"=>
  {"summary"=>
    ["DSPSVX uses the diagonal pivoting factorization A = U*D*U**T or",
     "A = L*D*L**T to compute the solution to a real system of linear",
     "equations A * X = B, where A is an N-by-N symmetric matrix stored",
     "in packed format and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "dtgsy2"=>
  {"summary"=>
    ["DTGSY2 solves the generalized Sylvester equation:",
     "            A * R - L * B = scale * C                (1)",
     "            D * R - L * E = scale * F,",
     "using Level 1 and 2 BLAS. where R and L are unknown M-by-N matrices,",
     "(A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M,",
     "N-by-N and M-by-N, respectively, with real entries. (A, D) and (B, E)",
     "must be in generalized Schur canonical form, i.e. A, B are upper",
     "quasi triangular and D, E are upper triangular. The solution (R, L)",
     "overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor",
     "chosen to avoid overflow.",
     "In matrix notation solving equation (1) corresponds to solve",
     "Z*x = scale*b, where Z is defined as",
     "       Z = [ kron(In, A)  -kron(B**T, Im) ]             (2)",
     "           [ kron(In, D)  -kron(E**T, Im) ],",
     "Ik is the identity matrix of size k and X**T is the transpose of X.",
     "kron(X, Y) is the Kronecker product between the matrices X and Y.",
     "In the process of solving (1), we solve a number of such systems",
     "where Dim(In), Dim(In) = 1 or 2.",
     "If TRANS = 'T', solve the transposed system Z**T*y = scale*b for y,",
     "which is equivalent to solve for R and L in",
     "            A**T * R  + D**T * L   = scale * C           (3)",
     "            R  * B**T + L  * E**T  = scale * -F",
     "This case is used to compute an estimate of Dif[(A, D), (B, E)] =",
     "sigma_min(Z) using reverse communicaton with DLACON.",
     "DTGSY2 also (IJOB >= 1) contributes to the computation in DTGSYL",
     "of an upper bound on the separation between to matrix pairs. Then",
     "the input (A, D), (B, E) are sub-pencils of the matrix pair in",
     "DTGSYL. See DTGSYL for details."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N', solve the generalized Sylvester equation (1).",
       "         = 'T': solve the 'transposed' system (3)."],
     "IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies what kind of functionality to be performed.",
       "         = 0: solve (1) only.",
       "         = 1: A contribution from this subsystem to a Frobenius",
       "              norm-based estimate of the separation between two matrix",
       "              pairs is computed. (look ahead strategy is used).",
       "         = 2: A contribution from this subsystem to a Frobenius",
       "              norm-based estimate of the separation between two matrix",
       "              pairs is computed. (DGECON on sub-systems is used.)",
       "         Not referenced if TRANS = 'T'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         On entry, M specifies the order of A and D, and the row",
       "         dimension of C, F, R and L."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         On entry, N specifies the order of B and E, and the column",
       "         dimension of C, F, R and L."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA, M)",
       "         On entry, A contains an upper quasi triangular matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the matrix A. LDA >= max(1, M)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         On entry, B contains an upper quasi triangular matrix."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the matrix B. LDB >= max(1, N)."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC, N)",
       "         On entry, C contains the right-hand-side of the first matrix",
       "         equation in (1).",
       "         On exit, if IJOB = 0, C has been overwritten by the",
       "         solution R."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the matrix C. LDC >= max(1, M)."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (LDD, M)",
       "         On entry, D contains an upper triangular matrix."],
     "LDD"=>
      ["[in]",
       "         LDD is INTEGER",
       "         The leading dimension of the matrix D. LDD >= max(1, M)."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (LDE, N)",
       "         On entry, E contains an upper triangular matrix."],
     "LDE"=>
      ["[in]",
       "         LDE is INTEGER",
       "         The leading dimension of the matrix E. LDE >= max(1, N)."],
     "F"=>
      ["[in,out]",
       "         F is DOUBLE PRECISION array, dimension (LDF, N)",
       "         On entry, F contains the right-hand-side of the second matrix",
       "         equation in (1).",
       "         On exit, if IJOB = 0, F has been overwritten by the",
       "         solution L."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the matrix F. LDF >= max(1, M)."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         On exit, 0 <= SCALE <= 1. If 0 < SCALE < 1, the solutions",
       "         R and L (C and F on entry) will hold the solutions to a",
       "         slightly perturbed system but the input matrices A, B, D and",
       "         E have not been changed. If SCALE = 0, R and L will hold the",
       "         solutions to the homogeneous system with C = F = 0. Normally,",
       "         SCALE = 1."],
     "RDSUM"=>
      ["[in,out]",
       "         RDSUM is DOUBLE PRECISION",
       "         On entry, the sum of squares of computed contributions to",
       "         the Dif-estimate under computation by DTGSYL, where the",
       "         scaling factor RDSCAL (see below) has been factored out.",
       "         On exit, the corresponding sum of squares updated with the",
       "         contributions from the current sub-system.",
       "         If TRANS = 'T' RDSUM is not touched.",
       "         NOTE: RDSUM only makes sense when DTGSY2 is called by DTGSYL."],
     "RDSCAL"=>
      ["[in,out]",
       "         RDSCAL is DOUBLE PRECISION",
       "         On entry, scaling factor used to prevent overflow in RDSUM.",
       "         On exit, RDSCAL is updated w.r.t. the current contributions",
       "         in RDSUM.",
       "         If TRANS = 'T', RDSCAL is not touched.",
       "         NOTE: RDSCAL only makes sense when DTGSY2 is called by",
       "               DTGSYL."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (M+N+2)"],
     "PQ"=>
      ["[out]",
       "         PQ is INTEGER",
       "         On exit, the number of subsystems (of size 2-by-2, 4-by-4 and",
       "         8-by-8) solved by this routine."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, if INFO is set to",
       "           =0: Successful exit",
       "           <0: If INFO = -i, the i-th argument had an illegal value.",
       "           >0: The matrix pairs (A, D) and (B, E) have common or very",
       "               close eigenvalues."]}},
 "dormrz"=>
  {"summary"=>
    ["DORMRZ overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by DTZRZF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix A containing",
       "         the meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DTZRZF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DTZRZF."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dptsv"=>
  {"summary"=>
    ["DPTSV computes the solution to a real system of linear equations",
     "A*X = B, where A is an N-by-N symmetric positive definite tridiagonal",
     "matrix, and X and B are N-by-NRHS matrices.",
     "A is factored as A = L*D*L**T, and the factored form of A is then",
     "used to solve the system of equations."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.  On exit, the n diagonal elements of the diagonal matrix",
       "         D from the factorization A = L*D*L**T."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A.  On exit, the (n-1) subdiagonal elements of the",
       "         unit bidiagonal factor L from the L*D*L**T factorization of",
       "         A.  (E can also be regarded as the superdiagonal of the unit",
       "         bidiagonal factor U from the U**T*D*U factorization of A.)"],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the solution has not been",
       "               computed.  The factorization has not been completed",
       "               unless i = N."]}},
 "ztfttp"=>
  {"summary"=>
    ["ZTFTTP copies a triangular matrix A from rectangular full packed",
     "format (TF) to standard packed format (TP)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF is in Normal format;",
       "         = 'C':  ARF is in Conjugate-transpose format;"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "ARF"=>
      ["[in]",
       "         ARF is COMPLEX*16 array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "AP"=>
      ["[out]",
       "         AP is COMPLEX*16 array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slarzb"=>
  {"summary"=>
    ["SLARZB applies a real block reflector H or its transpose H**T to",
     "a real distributed M-by-N  C from the left or the right.",
     "Currently, only STOREV = 'R' and DIRECT = 'B' are supported."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H**T from the Left",
       "         = 'R': apply H or H**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'C': apply H**T (Transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columnwise                        (not supported yet)",
       "         = 'R': Rowwise"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T (= the number of elementary",
       "         reflectors whose product defines the block reflector)."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of columns of the matrix V containing the",
       "         meaningful part of the Householder reflectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension (LDV,NV).",
       "         If STOREV = 'C', NV = K; if STOREV = 'R', NV = L."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= L; if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (LDT,K)",
       "         The triangular K-by-K matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (LDWORK,K)"],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= max(1,N);",
       "         if SIDE = 'R', LDWORK >= max(1,M)."]}},
 "ssysv_rk"=>
  {"summary"=>
    ["SSYSV_RK computes the solution to a real system of linear",
     "equations A * X = B, where A is an N-by-N symmetric matrix",
     "and X and B are N-by-NRHS matrices.",
     "The bounded Bunch-Kaufman (rook) diagonal pivoting method is used",
     "to factor A as",
     "   A = P*U*D*(U**T)*(P**T),  if UPLO = 'U', or",
     "   A = P*L*D*(L**T)*(P**T),  if UPLO = 'L',",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "SSYTRF_RK is called to compute the factorization of a real",
     "symmetric matrix.  The factored form of A is then used to solve",
     "the system of equations A * X = B by calling BLAS3 routine SSYTRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, if INFO = 0, diagonal of the block diagonal",
       "         matrix D and factors U or L  as computed by SSYTRF_RK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         For more info see the description of DSYTRF_RK routine."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N)",
       "         On exit, contains the output computed by the factorization",
       "         routine DSYTRF_RK, i.e. the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases.",
       "         For more info see the description of DSYTRF_RK routine."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D,",
       "         as determined by SSYTRF_RK.",
       "         For more info see the description of DSYTRF_RK routine."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension ( MAX(1,LWORK) ).",
       "         Work array used in the factorization stage.",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1. For best performance",
       "         of factorization stage LWORK >= max(1,N*NB), where NB is",
       "         the optimal blocksize for DSYTRF_RK.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array for factorization stage, returns this value as",
       "         the first entry of the WORK array, and no error message",
       "         related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "zpocon"=>
  {"summary"=>
    ["ZPOCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a complex Hermitian positive definite matrix using the",
     "Cholesky factorization A = U**H*U or A = L*L**H computed by ZPOTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H, as computed by ZPOTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm (or infinity-norm) of the Hermitian matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgetrf2"=>
  {"summary"=>
    ["SGETRF2 computes an LU factorization of a general M-by-N matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the recursive version of the algorithm. It divides",
     "the matrix into four submatrices:",
     "       [  A11 | A12  ]  where A11 is n1 by n1 and A22 is n2 by n2",
     "   A = [ -----|----- ]  with n1 = min(m,n)/2",
     "                                      [ A11 ]",
     "The subroutine calls itself to factor [ --- ],",
     "                                      [ A12 ]",
     "                [ A12 ]",
     "do the swaps on [ --- ], solve A12, update A22,",
     "                [ A22 ]",
     "then calls itself to factor A22 and do the swaps on A21."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "zhgeqz"=>
  {"summary"=>
    ["ZHGEQZ computes the eigenvalues of a complex matrix pair (H,T),",
     "where H is an upper Hessenberg matrix and T is upper triangular,",
     "using the single-shift QZ method.",
     "Matrix pairs of this type are produced by the reduction to",
     "generalized upper Hessenberg form of a complex matrix pair (A,B):",
     "   A = Q1*H*Z1**H,  B = Q1*T*Z1**H,",
     "as computed by ZGGHRD.",
     "If JOB='S', then the Hessenberg-triangular pair (H,T) is",
     "also reduced to generalized Schur form,",
     "   H = Q*S*Z**H,  T = Q*P*Z**H,",
     "where Q and Z are unitary matrices and S and P are upper triangular.",
     "Optionally, the unitary matrix Q from the generalized Schur",
     "factorization may be postmultiplied into an input matrix Q1, and the",
     "unitary matrix Z may be postmultiplied into an input matrix Z1.",
     "If Q1 and Z1 are the unitary matrices from ZGGHRD that reduced",
     "the matrix pair (A,B) to generalized Hessenberg form, then the output",
     "matrices Q1*Q and Z1*Z are the unitary factors from the generalized",
     "Schur factorization of (A,B):",
     "   A = (Q1*Q)*S*(Z1*Z)**H,  B = (Q1*Q)*P*(Z1*Z)**H.",
     "To avoid overflow, eigenvalues of the matrix pair (H,T)",
     "(equivalently, of (A,B)) are computed as a pair of complex values",
     "(alpha,beta).  If beta is nonzero, lambda = alpha / beta is an",
     "eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP)",
     "   A*x = lambda*B*x",
     "and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the",
     "alternate form of the GNEP",
     "   mu*A*y = B*y.",
     "The values of alpha and beta for the i-th eigenvalue can be read",
     "directly from the generalized Schur form:  alpha = S(i,i),",
     "beta = P(i,i).",
     "Ref: C.B. Moler & G.W. Stewart, \"An Algorithm for Generalized Matrix",
     "     Eigenvalue Problems\", SIAM J. Numer. Anal., 10(1973),",
     "     pp. 241--256."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         = 'E': Compute eigenvalues only;",
       "         = 'S': Computer eigenvalues and the Schur form."],
     "COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         = 'N': Left Schur vectors (Q) are not computed;",
       "         = 'I': Q is initialized to the unit matrix and the matrix Q",
       "                of left Schur vectors of (H,T) is returned;",
       "         = 'V': Q must contain a unitary matrix Q1 on entry and",
       "                the product Q1*Q is returned."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N': Right Schur vectors (Z) are not computed;",
       "         = 'I': Q is initialized to the unit matrix and the matrix Z",
       "                of right Schur vectors of (H,T) is returned;",
       "         = 'V': Z must contain a unitary matrix Z1 on entry and",
       "                the product Z1*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices H, T, Q, and Z.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI mark the rows and columns of H which are in",
       "         Hessenberg form.  It is assumed that A is already upper",
       "         triangular in rows and columns 1:ILO-1 and IHI+1:N.",
       "         If N > 0, 1 <= ILO <= IHI <= N; if N = 0, ILO=1 and IHI=0."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX*16 array, dimension (LDH, N)",
       "         On entry, the N-by-N upper Hessenberg matrix H.",
       "         On exit, if JOB = 'S', H contains the upper triangular",
       "         matrix S from the generalized Schur factorization.",
       "         If JOB = 'E', the diagonal of H matches that of S, but",
       "         the rest of H is unspecified."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max( 1, N )."],
     "T"=>
      ["[in,out]",
       "         T is COMPLEX*16 array, dimension (LDT, N)",
       "         On entry, the N-by-N upper triangular matrix T.",
       "         On exit, if JOB = 'S', T contains the upper triangular",
       "         matrix P from the generalized Schur factorization.",
       "         If JOB = 'E', the diagonal of T matches that of P, but",
       "         the rest of T is unspecified."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max( 1, N )."],
     "ALPHA"=>
      ["[out]",
       "         ALPHA is COMPLEX*16 array, dimension (N)",
       "         The complex scalars alpha that define the eigenvalues of",
       "         GNEP.  ALPHA(i) = S(i,i) in the generalized Schur",
       "         factorization."],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX*16 array, dimension (N)",
       "         The real non-negative scalars beta that define the",
       "         eigenvalues of GNEP.  BETA(i) = P(i,i) in the generalized",
       "         Schur factorization.",
       "         Together, the quantities alpha = ALPHA(j) and beta = BETA(j)",
       "         represent the j-th eigenvalue of the matrix pair (A,B), in",
       "         one of the forms lambda = alpha/beta or mu = beta/alpha.",
       "         Since either lambda or mu may overflow, they should not,",
       "         in general, be computed."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDQ, N)",
       "         On entry, if COMPQ = 'V', the unitary matrix Q1 used in the",
       "         reduction of (A,B) to generalized Hessenberg form.",
       "         On exit, if COMPQ = 'I', the unitary matrix of left Schur",
       "         vectors of (H,T), and if COMPQ = 'V', the unitary matrix of",
       "         left Schur vectors of (A,B).",
       "         Not referenced if COMPQ = 'N'."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= 1.",
       "         If COMPQ='V' or 'I', then LDQ >= N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         On entry, if COMPZ = 'V', the unitary matrix Z1 used in the",
       "         reduction of (A,B) to generalized Hessenberg form.",
       "         On exit, if COMPZ = 'I', the unitary matrix of right Schur",
       "         vectors of (H,T), and if COMPZ = 'V', the unitary matrix of",
       "         right Schur vectors of (A,B).",
       "         Not referenced if COMPZ = 'N'."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1.",
       "         If COMPZ='V' or 'I', then LDZ >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO >= 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         = 1,...,N: the QZ iteration did not converge.  (H,T) is not",
       "                    in Schur form, but ALPHA(i) and BETA(i),",
       "                    i=INFO+1,...,N should be correct.",
       "         = N+1,...,2*N: the shift calculation failed.  (H,T) is not",
       "                    in Schur form, but ALPHA(i) and BETA(i),",
       "                    i=INFO-N+1,...,N should be correct."]}},
 "cgetrf2"=>
  {"summary"=>
    ["CGETRF2 computes an LU factorization of a general M-by-N matrix A",
     "using partial pivoting with row interchanges.",
     "The factorization has the form",
     "   A = P * L * U",
     "where P is a permutation matrix, L is lower triangular with unit",
     "diagonal elements (lower trapezoidal if m > n), and U is upper",
     "triangular (upper trapezoidal if m < n).",
     "This is the recursive version of the algorithm. It divides",
     "the matrix into four submatrices:",
     "       [  A11 | A12  ]  where A11 is n1 by n1 and A22 is n2 by n2",
     "   A = [ -----|----- ]  with n1 = min(m,n)/2",
     "       [  A21 | A22  ]       n2 = n-n1",
     "                                      [ A11 ]",
     "The subroutine calls itself to factor [ --- ],",
     "                                      [ A12 ]",
     "                [ A12 ]",
     "do the swaps on [ --- ], solve A12, update A22,",
     "                [ A22 ]",
     "then calls itself to factor A22 and do the swaps on A21."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix to be factored.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (min(M,N))",
       "         The pivot indices; for 1 <= i <= min(M,N), row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero. The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and division by zero will occur if it is used",
       "               to solve a system of equations."]}},
 "dtgsyl"=>
  {"summary"=>
    ["DTGSYL solves the generalized Sylvester equation:",
     "            A * R - L * B = scale * C                 (1)",
     "            D * R - L * E = scale * F",
     "where R and L are unknown m-by-n matrices, (A, D), (B, E) and",
     "(C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n,",
     "respectively, with real entries. (A, D) and (B, E) must be in",
     "generalized (real) Schur canonical form, i.e. A, B are upper quasi",
     "triangular and D, E are upper triangular.",
     "The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output",
     "scaling factor chosen to avoid overflow.",
     "In matrix notation (1) is equivalent to solve  Zx = scale b, where",
     "Z is defined as",
     "           Z = [ kron(In, A)  -kron(B**T, Im) ]         (2)",
     "               [ kron(In, D)  -kron(E**T, Im) ].",
     "Here Ik is the identity matrix of size k and X**T is the transpose of",
     "X. kron(X, Y) is the Kronecker product between the matrices X and Y.",
     "If TRANS = 'T', DTGSYL solves the transposed system Z**T*y = scale*b,",
     "which is equivalent to solve for R and L in",
     "            A**T * R + D**T * L = scale * C           (3)",
     "            R * B**T + L * E**T = scale * -F",
     "This case (TRANS = 'T') is used to compute an one-norm-based estimate",
     "of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D)",
     "and (B,E), using DLACON.",
     "If IJOB >= 1, DTGSYL computes a Frobenius norm-based estimate",
     "of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the",
     "reciprocal of the smallest singular value of Z. See [1-2] for more",
     "information.",
     "This is a level 3 BLAS algorithm."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N', solve the generalized Sylvester equation (1).",
       "         = 'T', solve the 'transposed' system (3)."],
     "IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies what kind of functionality to be performed.",
       "          =0: solve (1) only.",
       "          =1: The functionality of 0 and 3.",
       "          =2: The functionality of 0 and 4.",
       "          =3: Only an estimate of Dif[(A,D), (B,E)] is computed.",
       "              (look ahead strategy IJOB  = 1 is used).",
       "          =4: Only an estimate of Dif[(A,D), (B,E)] is computed.",
       "              ( DGECON on sub-systems is used ).",
       "         Not referenced if TRANS = 'T'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The order of the matrices A and D, and the row dimension of",
       "         the matrices C, F, R and L."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices B and E, and the column dimension",
       "         of the matrices C, F, R and L."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA, M)",
       "         The upper quasi triangular matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1, M)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB, N)",
       "         The upper quasi triangular matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1, N)."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC, N)",
       "         On entry, C contains the right-hand-side of the first matrix",
       "         equation in (1) or (3).",
       "         On exit, if IJOB = 0, 1 or 2, C has been overwritten by",
       "         the solution R. If IJOB = 3 or 4 and TRANS = 'N', C holds R,",
       "         the solution achieved during the computation of the",
       "         Dif-estimate."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1, M)."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (LDD, M)",
       "         The upper triangular matrix D."],
     "LDD"=>
      ["[in]",
       "         LDD is INTEGER",
       "         The leading dimension of the array D. LDD >= max(1, M)."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (LDE, N)",
       "         The upper triangular matrix E."],
     "LDE"=>
      ["[in]",
       "         LDE is INTEGER",
       "         The leading dimension of the array E. LDE >= max(1, N)."],
     "F"=>
      ["[in,out]",
       "         F is DOUBLE PRECISION array, dimension (LDF, N)",
       "         On entry, F contains the right-hand-side of the second matrix",
       "         equation in (1) or (3).",
       "         On exit, if IJOB = 0, 1 or 2, F has been overwritten by",
       "         the solution L. If IJOB = 3 or 4 and TRANS = 'N', F holds L,",
       "         the solution achieved during the computation of the",
       "         Dif-estimate."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the array F. LDF >= max(1, M)."],
     "DIF"=>
      ["[out]",
       "         DIF is DOUBLE PRECISION",
       "         On exit DIF is the reciprocal of a lower bound of the",
       "         reciprocal of the Dif-function, i.e. DIF is an upper bound of",
       "         Dif[(A,D), (B,E)] = sigma_min(Z), where Z as in (2).",
       "         IF IJOB = 0 or TRANS = 'T', DIF is not touched."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         On exit SCALE is the scaling factor in (1) or (3).",
       "         If 0 < SCALE < 1, C and F hold the solutions R and L, resp.,",
       "         to a slightly perturbed system but the input matrices A, B, D",
       "         and E have not been changed. If SCALE = 0, C and F hold the",
       "         solutions R and L, respectively, to the homogeneous system",
       "         with C = F = 0. Normally, SCALE = 1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK > = 1.",
       "         If IJOB = 1 or 2 and TRANS = 'N', LWORK >= max(1,2*M*N).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (M+N+6)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "           =0: successful exit",
       "           <0: If INFO = -i, the i-th argument had an illegal value.",
       "           >0: (A, D) and (B, E) have common or close eigenvalues."]}},
 "cung2r"=>
  {"summary"=>
    ["CUNG2R generates an m by n complex matrix Q with orthonormal columns,",
     "which is defined as the first n columns of a product of k elementary",
     "reflectors of order m",
     "      Q  =  H(1) H(2) . . . H(k)",
     "as returned by CGEQRF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the i-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by CGEQRF in the first k columns of its array",
       "         argument A.",
       "         On exit, the m by n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGEQRF."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "dlatrd"=>
  {"summary"=>
    ["DLATRD reduces NB rows and columns of a real symmetric matrix A to",
     "symmetric tridiagonal form by an orthogonal similarity",
     "transformation Q**T * A * Q, and returns the matrices V and W which are",
     "needed to apply the transformation to the unreduced part of A.",
     "If UPLO = 'U', DLATRD reduces the last NB rows and columns of a",
     "matrix, of which the upper triangle is supplied;",
     "if UPLO = 'L', DLATRD reduces the first NB rows and columns of a",
     "matrix, of which the lower triangle is supplied.",
     "This is an auxiliary routine called by DSYTRD."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U': Upper triangular",
       "         = 'L': Lower triangular"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of rows and columns to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit:",
       "         if UPLO = 'U', the last NB columns have been reduced to",
       "           tridiagonal form, with the diagonal elements overwriting",
       "           the diagonal elements of A; the elements above the diagonal",
       "           with the array TAU, represent the orthogonal matrix Q as a",
       "           product of elementary reflectors;",
       "         if UPLO = 'L', the first NB columns have been reduced to",
       "           tridiagonal form, with the diagonal elements overwriting",
       "           the diagonal elements of A; the elements below the diagonal",
       "           with the array TAU, represent the  orthogonal matrix Q as a",
       "           product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= (1,N)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         If UPLO = 'U', E(n-nb:n-1) contains the superdiagonal",
       "         elements of the last NB columns of the reduced matrix;",
       "         if UPLO = 'L', E(1:nb) contains the subdiagonal elements of",
       "         the first NB columns of the reduced matrix."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors, stored in",
       "         TAU(n-nb:n-1) if UPLO = 'U', and in TAU(1:nb) if UPLO = 'L'.",
       "         See Further Details."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (LDW,NB)",
       "         The n-by-nb matrix W required to update the unreduced part",
       "         of A."],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W. LDW >= max(1,N)."]}},
 "zpbtrs"=>
  {"summary"=>
    ["ZPBTRS solves a system of linear equations A*X = B with a Hermitian",
     "positive definite band matrix A using the Cholesky factorization",
     "A = U**H *U or A = L*L**H computed by ZPBTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangular factor stored in AB;",
       "         = 'L':  Lower triangular factor stored in AB."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H *U or A = L*L**H of the band matrix A, stored in the",
       "         first KD+1 rows of the array.  The j-th column of U or L is",
       "         stored in the j-th column of the array AB as follows:",
       "         if UPLO ='U', AB(kd+1+i-j,j) = U(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO ='L', AB(1+i-j,j)    = L(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dtgsna"=>
  {"summary"=>
    ["DTGSNA estimates reciprocal condition numbers for specified",
     "eigenvalues and/or eigenvectors of a matrix pair (A, B) in",
     "generalized real Schur canonical form (or of any matrix pair",
     "(Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where",
     "Z**T denotes the transpose of Z.",
     "(A, B) must be in generalized real Schur form (as returned by DGGES),",
     "i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal",
     "blocks. B is upper triangular."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for",
       "         eigenvalues (S) or eigenvectors (DIF):",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for eigenvectors only (DIF);",
       "         = 'B': for both eigenvalues and eigenvectors (S and DIF)."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute condition numbers for all eigenpairs;",
       "         = 'S': compute condition numbers for selected eigenpairs",
       "                specified by the array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenpairs for which",
       "         condition numbers are required. To select condition numbers",
       "         for the eigenpair corresponding to a real eigenvalue w(j),",
       "         SELECT(j) must be set to .TRUE.. To select condition numbers",
       "         corresponding to a complex conjugate pair of eigenvalues w(j)",
       "         and w(j+1), either SELECT(j) or SELECT(j+1) or both, must be",
       "         set to .TRUE..",
       "         If HOWMNY = 'A', SELECT is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the square matrix pair (A, B). N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The upper quasi-triangular matrix A in the pair (A,B)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         The upper triangular matrix B in the pair (A,B)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION array, dimension (LDVL,M)",
       "         If JOB = 'E' or 'B', VL must contain left eigenvectors of",
       "         (A, B), corresponding to the eigenpairs specified by HOWMNY",
       "         and SELECT. The eigenvectors must be stored in consecutive",
       "         columns of VL, as returned by DTGEVC.",
       "         If JOB = 'V', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL. LDVL >= 1.",
       "         If JOB = 'E' or 'B', LDVL >= N."],
     "VR"=>
      ["[in]",
       "         VR is DOUBLE PRECISION array, dimension (LDVR,M)",
       "         If JOB = 'E' or 'B', VR must contain right eigenvectors of",
       "         (A, B), corresponding to the eigenpairs specified by HOWMNY",
       "         and SELECT. The eigenvectors must be stored in consecutive",
       "         columns ov VR, as returned by DTGEVC.",
       "         If JOB = 'V', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR. LDVR >= 1.",
       "         If JOB = 'E' or 'B', LDVR >= N."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (MM)",
       "         If JOB = 'E' or 'B', the reciprocal condition numbers of the",
       "         selected eigenvalues, stored in consecutive elements of the",
       "         array. For a complex conjugate pair of eigenvalues two",
       "         consecutive elements of S are set to the same value. Thus",
       "         S(j), DIF(j), and the j-th columns of VL and VR all",
       "         correspond to the same eigenpair (but not in general the",
       "         j-th eigenpair, unless all eigenpairs are selected).",
       "         If JOB = 'V', S is not referenced."],
     "DIF"=>
      ["[out]",
       "         DIF is DOUBLE PRECISION array, dimension (MM)",
       "         If JOB = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the selected eigenvectors, stored in consecutive",
       "         elements of the array. For a complex eigenvector two",
       "         consecutive elements of DIF are set to the same value. If",
       "         the eigenvalues cannot be reordered to compute DIF(j), DIF(j)",
       "         is set to 0; this can only occur when the true value would be",
       "         very small anyway.",
       "         If JOB = 'E', DIF is not referenced."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of elements in the arrays S and DIF. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of elements of the arrays S and DIF used to store",
       "         the specified condition numbers; for each selected real",
       "         eigenvalue one element is used, and for each selected complex",
       "         conjugate pair of eigenvalues, two elements are used.",
       "         If HOWMNY = 'A', M is set to N."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N).",
       "         If JOB = 'V' or 'B' LWORK >= 2*N*(N+2)+16.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N + 6)",
       "         If JOB = 'E', IWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         =0: Successful exit",
       "         <0: If INFO = -i, the i-th argument had an illegal value"]}},
 "zsytrs_rook"=>
  {"summary"=>
    ["ZSYTRS_ROOK solves a system of linear equations A*X = B with",
     "a complex symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by ZSYTRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF_ROOK."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dggbal"=>
  {"summary"=>
    ["DGGBAL balances a pair of general real matrices (A,B).  This",
     "involves, first, permuting A and B by similarity transformations to",
     "isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N",
     "elements on the diagonal; and second, applying a diagonal similarity",
     "transformation to rows and columns ILO to IHI to make the rows",
     "and columns as close in norm as possible. Both steps are optional.",
     "Balancing may reduce the 1-norm of the matrices, and improve the",
     "accuracy of the computed eigenvalues and/or eigenvectors in the",
     "generalized eigenvalue problem A*x = lambda*B*x."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the operations to be performed on A and B:",
       "         = 'N':  none:  simply set ILO = 1, IHI = N, LSCALE(I) = 1.0",
       "                 and RSCALE(I) = 1.0 for i = 1,...,N.",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the input matrix A.",
       "         On exit,  A is overwritten by the balanced matrix.",
       "         If JOB = 'N', A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the input matrix B.",
       "         On exit,  B is overwritten by the balanced matrix.",
       "         If JOB = 'N', B is not referenced."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are set to integers such that on exit",
       "         A(i,j) = 0 and B(i,j) = 0 if i > j and",
       "         j = 1,...,ILO-1 or i = IHI+1,...,N.",
       "         If JOB = 'N' or 'S', ILO = 1 and IHI = N."],
     "LSCALE"=>
      ["[out]",
       "         LSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the left side of A and B.  If P(j) is the index of the",
       "         row interchanged with row j, and D(j)",
       "         is the scaling factor applied to row j, then",
       "           LSCALE(j) = P(j)    for J = 1,...,ILO-1",
       "                     = D(j)    for J = ILO,...,IHI",
       "                     = P(j)    for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "RSCALE"=>
      ["[out]",
       "         RSCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the right side of A and B.  If P(j) is the index of the",
       "         column interchanged with column j, and D(j)",
       "         is the scaling factor applied to column j, then",
       "           LSCALE(j) = P(j)    for J = 1,...,ILO-1",
       "                     = D(j)    for J = ILO,...,IHI",
       "                     = P(j)    for J = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (lwork)",
       "         lwork must be at least max(1,6*N) when JOB = 'S' or 'B', and",
       "         at least 1 when JOB = 'N' or 'P'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slange"=>
  {"summary"=>
    ["SLANGE  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "real matrix A.",
     "   SLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANGE as described",
       "         above."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0.  When M = 0,",
       "         SLANGE is set to zero."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0.  When N = 0,",
       "         SLANGE is set to zero."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= M when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "zla_porcond_x"=>
  {"summary"=>
    ["   ZLA_PORCOND_X Computes the infinity norm condition number of",
     "   op(A) * diag(X) where X is a COMPLEX*16 vector."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**H*U or A = L*L**H, as computed by ZPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension (N)",
       "    The vector X in the formula op(A) * diag(X)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX*16 array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is DOUBLE PRECISION array, dimension (N).",
       "    Workspace."]}},
 "slasd7"=>
  {"summary"=>
    ["SLASD7 merges the two sets of singular values together into a single",
     "sorted set. Then it tries to deflate the size of the problem. There",
     "are two ways in which deflation can occur:  when two or more singular",
     "values are close together or if there is a tiny entry in the Z",
     "vector. For each such occurrence the order of the related",
     "secular equation problem is reduced by one.",
     "SLASD7 is called from SLASD6."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "         Specifies whether singular vectors are to be computed",
       "         in compact form, as follows:",
       "         = 0: Compute singular values only.",
       "         = 1: Compute singular vectors of upper",
       "              bidiagonal matrix in compact form."],
     "NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block. NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block. NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has",
       "        N = NL + NR + 1 rows and",
       "        M = N + SQRE >= N columns."],
     "K"=>
      ["[out]",
       "         K is INTEGER",
       "        Contains the dimension of the non-deflated matrix, this is",
       "        the order of the related secular equation. 1 <= K <=N."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension ( N )",
       "        On entry D contains the singular values of the two submatrices",
       "        to be combined. On exit D contains the trailing (N-K) updated",
       "        singular values (those which were deflated) sorted into",
       "        increasing order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension ( M )",
       "        On exit Z contains the updating row vector in the secular",
       "        equation."],
     "ZW"=>
      ["[out]",
       "         ZW is REAL array, dimension ( M )",
       "        Workspace for Z."],
     "VF"=>
      ["[in,out]",
       "         VF is REAL array, dimension ( M )",
       "        On entry, VF(1:NL+1) contains the first components of all",
       "        right singular vectors of the upper block; and VF(NL+2:M)",
       "        contains the first components of all right singular vectors",
       "        of the lower block. On exit, VF contains the first components",
       "        of all right singular vectors of the bidiagonal matrix."],
     "VFW"=>
      ["[out]",
       "         VFW is REAL array, dimension ( M )",
       "        Workspace for VF."],
     "VL"=>
      ["[in,out]",
       "         VL is REAL array, dimension ( M )",
       "        On entry, VL(1:NL+1) contains the  last components of all",
       "        right singular vectors of the upper block; and VL(NL+2:M)",
       "        contains the last components of all right singular vectors",
       "        of the lower block. On exit, VL contains the last components",
       "        of all right singular vectors of the bidiagonal matrix."],
     "VLW"=>
      ["[out]",
       "         VLW is REAL array, dimension ( M )",
       "        Workspace for VL."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "        Contains the diagonal element associated with the added row."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL",
       "        Contains the off-diagonal element associated with the added",
       "        row."],
     "DSIGMA"=>
      ["[out]",
       "         DSIGMA is REAL array, dimension ( N )",
       "        Contains a copy of the diagonal elements (K-1 singular values",
       "        and one zero) in the secular equation."],
     "IDX"=>
      ["[out]",
       "         IDX is INTEGER array, dimension ( N )",
       "        This will contain the permutation used to sort the contents of",
       "        D into ascending order."],
     "IDXP"=>
      ["[out]",
       "         IDXP is INTEGER array, dimension ( N )",
       "        This will contain the permutation used to place deflated",
       "        values of D at the end of the array. On output IDXP(2:K)",
       "        points to the nondeflated D-values and IDXP(K+1:N)",
       "        points to the deflated singular values."],
     "IDXQ"=>
      ["[in]",
       "         IDXQ is INTEGER array, dimension ( N )",
       "        This contains the permutation which separately sorts the two",
       "        sub-problems in D into ascending order.  Note that entries in",
       "        the first half of this permutation must first be moved one",
       "        position backward; and entries in the second half",
       "        must first have NL+1 added to their values."],
     "PERM"=>
      ["[out]",
       "         PERM is INTEGER array, dimension ( N )",
       "        The permutations (from deflation and sorting) to be applied",
       "        to each singular block. Not referenced if ICOMPQ = 0."],
     "GIVPTR"=>
      ["[out]",
       "         GIVPTR is INTEGER",
       "        The number of Givens rotations which took place in this",
       "        subproblem. Not referenced if ICOMPQ = 0."],
     "GIVCOL"=>
      ["[out]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation. Not referenced if ICOMPQ = 0."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER",
       "        The leading dimension of GIVCOL, must be at least N."],
     "GIVNUM"=>
      ["[out]",
       "         GIVNUM is REAL array, dimension ( LDGNUM, 2 )",
       "        Each number indicates the C or S value to be used in the",
       "        corresponding Givens rotation. Not referenced if ICOMPQ = 0."],
     "LDGNUM"=>
      ["[in]",
       "         LDGNUM is INTEGER",
       "        The leading dimension of GIVNUM, must be at least N."],
     "C"=>
      ["[out]",
       "         C is REAL",
       "        C contains garbage if SQRE =0 and the C-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "S"=>
      ["[out]",
       "         S is REAL",
       "        S contains garbage if SQRE =0 and the S-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit.",
       "        < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "csyconv"=>
  {"summary"=>
    ["CSYCONV convert A given by TRF into L and D and vice-versa.",
     "Get Non-diag elements of D (returned in workspace) and",
     "apply or reverse permutation done in TRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "WAY"=>
      ["[in]",
       "         WAY is CHARACTER*1",
       "         = 'C': Convert",
       "         = 'R': Revert"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF."],
     "E"=>
      ["[out]",
       "         E is COMPLEX array, dimension (N)",
       "         E stores the supdiagonal/subdiagonal of the symmetric 1-by-1",
       "         or 2-by-2 block diagonal matrix D in LDLT."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlansy"=>
  {"summary"=>
    ["DLANSY  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "real symmetric matrix A.",
     "   DLANSY = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANSY as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is to be referenced.",
       "         = 'U':  Upper triangular part of A is referenced",
       "         = 'L':  Lower triangular part of A is referenced"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, DLANSY is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The symmetric matrix A.  If UPLO = 'U', the leading n by n",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading n by n lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "zgesvj"=>
  {"summary"=>
    ["ZGESVJ computes the singular value decomposition (SVD) of a complex",
     "M-by-N matrix A, where M >= N. The SVD of A is written as",
     "                                   [++]   [xx]   [x0]   [xx]",
     "             A = U * SIGMA * V^*,  [++] = [xx] * [ox] * [xx]",
     "                                   [++]   [xx]",
     "where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal",
     "matrix, and V is an N-by-N unitary matrix. The diagonal elements",
     "of SIGMA are the singular values of A. The columns of U and V are the",
     "left and the right singular vectors of A, respectively."],
   "param"=>
    {"JOBA"=>
      ["[in]",
       "         JOBA is CHARACTER* 1",
       "         Specifies the structure of A.",
       "         = 'L': The input matrix A is lower triangular;",
       "         = 'U': The input matrix A is upper triangular;",
       "         = 'G': The input matrix A is general M-by-N matrix, M >= N."],
     "JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies whether to compute the left singular vectors",
       "         (columns of U):",
       "         = 'U' or 'F': The left singular vectors corresponding to the nonzero",
       "                singular values are computed and returned in the leading",
       "                columns of A. See more details in the description of A.",
       "                The default numerical orthogonality threshold is set to",
       "                approximately TOL=CTOL*EPS, CTOL=SQRT(M), EPS=DLAMCH('E').",
       "         = 'C': Analogous to JOBU='U', except that user can control the",
       "                level of numerical orthogonality of the computed left",
       "                singular vectors. TOL can be set to TOL = CTOL*EPS, where",
       "                CTOL is given on input in the array WORK.",
       "                No CTOL smaller than ONE is allowed. CTOL greater",
       "                than 1 / EPS is meaningless. The option 'C'",
       "                can be used if M*EPS is satisfactory orthogonality",
       "                of the computed left singular vectors, so CTOL=M could",
       "                save few sweeps of Jacobi rotations.",
       "                See the descriptions of A and WORK(1).",
       "         = 'N': The matrix U is not computed. However, see the",
       "                description of A."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether to compute the right singular vectors, that",
       "         is, the matrix V:",
       "         = 'V' or 'J': the matrix V is computed and returned in the array V",
       "         = 'A' : the Jacobi rotations are applied to the MV-by-N",
       "                 array V. In other words, the right singular vector",
       "                 matrix V is not computed explicitly; instead it is",
       "                 applied to an MV-by-N matrix initially stored in the",
       "                 first MV rows of V.",
       "         = 'N' : the matrix V is not computed and the array V is not",
       "                 referenced"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A. 1/DLAMCH('E') > M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         If JOBU .EQ. 'U' .OR. JOBU .EQ. 'C':",
       "                If INFO .EQ. 0 :",
       "                RANKA orthonormal columns of U are returned in the",
       "                leading RANKA columns of the array A. Here RANKA <= N",
       "                is the number of computed singular values of A that are",
       "                above the underflow threshold DLAMCH('S'). The singular",
       "                vectors corresponding to underflowed or zero singular",
       "                values are not computed. The value of RANKA is returned",
       "                in the array RWORK as RANKA=NINT(RWORK(2)). Also see the",
       "                descriptions of SVA and RWORK. The computed columns of U",
       "                are mutually numerically orthogonal up to approximately",
       "                TOL=SQRT(M)*EPS (default); or TOL=CTOL*EPS (JOBU.EQ.'C'),",
       "                see the description of JOBU.",
       "                If INFO .GT. 0,",
       "                the procedure ZGESVJ did not converge in the given number",
       "                of iterations (sweeps). In that case, the computed",
       "                columns of U may not be orthogonal up to TOL. The output",
       "                U (stored in A), SIGMA (given by the computed singular",
       "                values in SVA(1:N)) and V is still a decomposition of the",
       "                input matrix A in the sense that the residual",
       "                || A - SCALE * U * SIGMA * V^* ||_2 / ||A||_2 is small.",
       "         If JOBU .EQ. 'N':",
       "                If INFO .EQ. 0 :",
       "                Note that the left singular vectors are 'for free' in the",
       "                one-sided Jacobi SVD algorithm. However, if only the",
       "                singular values are needed, the level of numerical",
       "                orthogonality of U is not an issue and iterations are",
       "                stopped when the columns of the iterated matrix are",
       "                numerically orthogonal up to approximately M*EPS. Thus,",
       "                on exit, A contains the columns of U scaled with the",
       "                corresponding singular values.",
       "                If INFO .GT. 0 :",
       "                the procedure ZGESVJ did not converge in the given number",
       "                of iterations (sweeps)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "SVA"=>
      ["[out]",
       "         SVA is DOUBLE PRECISION array, dimension (N)",
       "         On exit,",
       "         If INFO .EQ. 0 :",
       "         depending on the value SCALE = RWORK(1), we have:",
       "                If SCALE .EQ. ONE:",
       "                SVA(1:N) contains the computed singular values of A.",
       "                During the computation SVA contains the Euclidean column",
       "                norms of the iterated matrices in the array A.",
       "                If SCALE .NE. ONE:",
       "                The singular values of A are SCALE*SVA(1:N), and this",
       "                factored representation is due to the fact that some of the",
       "                singular values of A might underflow or overflow.",
       "         If INFO .GT. 0 :",
       "         the procedure ZGESVJ did not converge in the given number of",
       "         iterations (sweeps) and SCALE*SVA(1:N) may not be accurate."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then the product of Jacobi rotations in ZGESVJ",
       "         is applied to the first MV rows of V. See the description of JOBV."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX*16 array, dimension (LDV,N)",
       "         If JOBV = 'V', then V contains on exit the N-by-N matrix of",
       "                        the right singular vectors;",
       "         If JOBV = 'A', then V contains the product of the computed right",
       "                        singular vector matrix and the initial matrix in",
       "                        the array V.",
       "         If JOBV = 'N', then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V, LDV .GE. 1.",
       "         If JOBV .EQ. 'V', then LDV .GE. max(1,N).",
       "         If JOBV .EQ. 'A', then LDV .GE. max(1,MV) ."],
     "CWORK"=>
      ["[in,out]",
       "         CWORK is COMPLEX*16 array, dimension max(1,LWORK).",
       "         Used as workspace.",
       "         If on entry LWORK .EQ. -1, then a workspace query is assumed and",
       "         no computation is done; CWORK(1) is set to the minial (and optimal)",
       "         length of CWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER.",
       "         Length of CWORK, LWORK >= M+N."],
     "RWORK"=>
      ["[in,out]",
       "         RWORK is DOUBLE PRECISION array, dimension max(6,LRWORK).",
       "         On entry,",
       "         If JOBU .EQ. 'C' :",
       "         RWORK(1) = CTOL, where CTOL defines the threshold for convergence.",
       "                   The process stops if all columns of A are mutually",
       "                   orthogonal up to CTOL*EPS, EPS=DLAMCH('E').",
       "                   It is required that CTOL >= ONE, i.e. it is not",
       "                   allowed to force the routine to obtain orthogonality",
       "                   below EPSILON.",
       "         On exit,",
       "         RWORK(1) = SCALE is the scaling factor such that SCALE*SVA(1:N)",
       "                   are the computed singular values of A.",
       "                   (See description of SVA().)",
       "         RWORK(2) = NINT(RWORK(2)) is the number of the computed nonzero",
       "                   singular values.",
       "         RWORK(3) = NINT(RWORK(3)) is the number of the computed singular",
       "                   values that are larger than the underflow threshold.",
       "         RWORK(4) = NINT(RWORK(4)) is the number of sweeps of Jacobi",
       "                   rotations needed for numerical convergence.",
       "         RWORK(5) = max_{i.NE.j} |COS(A(:,i),A(:,j))| in the last sweep.",
       "                   This is useful information in cases when ZGESVJ did",
       "                   not converge, as it can be used to estimate whether",
       "                   the output is stil useful and for post festum analysis.",
       "         RWORK(6) = the largest absolute value over all sines of the",
       "                   Jacobi rotation angles in the last sweep. It can be",
       "                   useful for a post festum analysis.",
       "        If on entry LRWORK .EQ. -1, then a workspace query is assumed and",
       "        no computation is done; RWORK(1) is set to the minial (and optimal)",
       "        length of RWORK."],
     "LRWORK"=>
      ["[in]",
       "        LRWORK is INTEGER",
       "        Length of RWORK, LRWORK >= MAX(6,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value",
       "         > 0 : ZGESVJ did not converge in the maximal allowed number",
       "               (NSWEEP=30) of sweeps. The output may still be useful.",
       "               See the description of RWORK."]}},
 "zlarz"=>
  {"summary"=>
    ["ZLARZ applies a complex elementary reflector H to a complex",
     "M-by-N matrix C, from either the left or the right. H is represented",
     "in the form",
     "      H = I - tau * v * v**H",
     "where tau is a complex scalar and v is a complex vector.",
     "If tau = 0, then H is taken to be the unit matrix.",
     "To apply H**H (the conjugate transpose of H), supply conjg(tau) instead",
     "tau.",
     "H is a product of k elementary reflectors as returned by ZTZRZF."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of entries of the vector V containing",
       "         the meaningful part of the Householder vectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension (1+(L-1)*abs(INCV))",
       "         The vector v in the representation of H as returned by",
       "         ZTZRZF. V is not used if TAU = 0."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between elements of v. INCV <> 0."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension",
       "                        (N) if SIDE = 'L'",
       "                     or (M) if SIDE = 'R'"]}},
 "ztbtrs"=>
  {"summary"=>
    ["ZTBTRS solves a triangular system of the form",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B,",
     "where A is a triangular band matrix of order N, and B is an",
     "N-by-NRHS matrix.  A check is made to verify that A is nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of AB.  The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element of A is zero,",
       "               indicating that the matrix is singular and the",
       "               solutions X have not been computed."]}},
 "ctptri"=>
  {"summary"=>
    ["CTPTRI computes the inverse of a complex upper or lower triangular",
     "matrix A stored in packed format."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangular matrix A, stored",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*((2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         See below for further details.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same packed storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, A(i,i) is exactly zero.  The triangular",
       "               matrix is singular and its inverse can not be computed."]}},
 "slarrd"=>
  {"summary"=>
    ["SLARRD computes the eigenvalues of a symmetric tridiagonal",
     "matrix T to suitable accuracy. This is an auxiliary code to be",
     "called from SSTEMR.",
     "The user may ask for all eigenvalues, all eigenvalues",
     "in the half-open interval (VL, VU], or the IL-th through IU-th",
     "eigenvalues.",
     "To avoid overflow, the matrix must be scaled so that its",
     "largest element is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest",
     "accuracy, it should not be much smaller than that.",
     "See W. Kahan \"Accurate Eigenvalues of a Symmetric Tridiagonal",
     "Matrix\", Report CS41, Computer Science Dept., Stanford",
     "University, July 21, 1966."],
   "param"=>
    {"RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': (\"All\")   all eigenvalues will be found.",
       "         = 'V': (\"Value\") all eigenvalues in the half-open interval",
       "                          (VL, VU] will be found.",
       "         = 'I': (\"Index\") the IL-th through IU-th eigenvalues (of the",
       "                          entire matrix) will be found."],
     "ORDER"=>
      ["[in]",
       "         ORDER is CHARACTER*1",
       "         = 'B': (\"By Block\") the eigenvalues will be grouped by",
       "                             split-off block (see IBLOCK, ISPLIT) and",
       "                             ordered from smallest to largest within",
       "                             the block.",
       "         = 'E': (\"Entire matrix\")",
       "                             the eigenvalues for the entire matrix",
       "                             will be ordered from smallest to",
       "                             largest."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix T.  N >= 0."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues.  Eigenvalues less than or equal",
       "         to VL, or greater than VU, will not be returned.  VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues.  Eigenvalues less than or equal",
       "         to VL, or greater than VU, will not be returned.  VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "GERS"=>
      ["[in]",
       "         GERS is REAL array, dimension (2*N)",
       "         The N Gerschgorin intervals (the i-th Gerschgorin interval",
       "         is (GERS(2*i-1), GERS(2*i))."],
     "RELTOL"=>
      ["[in]",
       "         RELTOL is REAL",
       "         The minimum relative width of an interval.  When an interval",
       "         is narrower than RELTOL times the larger (in",
       "         magnitude) endpoint, then it is considered to be",
       "         sufficiently small, i.e., converged.  Note: this should",
       "         always be at least radix*machine epsilon."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the tridiagonal matrix T."],
     "E2"=>
      ["[in]",
       "         E2 is REAL array, dimension (N-1)",
       "         The (n-1) squared off-diagonal elements of the tridiagonal matrix T."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "         The minimum pivot allowed in the Sturm sequence for T."],
     "NSPLIT"=>
      ["[in]",
       "         NSPLIT is INTEGER",
       "         The number of diagonal blocks in the matrix T.",
       "         1 <= NSPLIT <= N."],
     "ISPLIT"=>
      ["[in]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into submatrices.",
       "         The first submatrix consists of rows/columns 1 to ISPLIT(1),",
       "         the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),",
       "         etc., and the NSPLIT-th consists of rows/columns",
       "         ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.",
       "         (Only the first NSPLIT elements will actually be used, but",
       "         since the user cannot know a priori what value NSPLIT will",
       "         have, N words must be reserved for ISPLIT.)"],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The actual number of eigenvalues found. 0 <= M <= N.",
       "         (See also the description of INFO=2,3.)"],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         On exit, the first M elements of W will contain the",
       "         eigenvalue approximations. SLARRD computes an interval",
       "         I_j = (a_j, b_j] that includes eigenvalue j. The eigenvalue",
       "         approximation is given as the interval midpoint",
       "         W(j)= ( a_j + b_j)/2. The corresponding error is bounded by",
       "         WERR(j) = abs( a_j - b_j)/2"],
     "WERR"=>
      ["[out]",
       "         WERR is REAL array, dimension (N)",
       "         The error bound on the corresponding eigenvalue approximation",
       "         in W."],
     "WL"=>["[out]", "         WL is REAL"],
     "WU"=>
      ["[out]",
       "         WU is REAL",
       "         The interval (WL, WU] contains all the wanted eigenvalues.",
       "         If RANGE='V', then WL=VL and WU=VU.",
       "         If RANGE='A', then WL and WU are the global Gerschgorin bounds",
       "                       on the spectrum.",
       "         If RANGE='I', then WL and WU are computed by SLAEBZ from the",
       "                       index range specified."],
     "IBLOCK"=>
      ["[out]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         At each row/column j where E(j) is zero or small, the",
       "         matrix T is considered to split into a block diagonal",
       "         matrix.  On exit, if INFO = 0, IBLOCK(i) specifies to which",
       "         block (from 1 to the number of blocks) the eigenvalue W(i)",
       "         belongs.  (SLARRD may use the remaining N-M elements as",
       "         workspace.)"],
     "INDEXW"=>
      ["[out]",
       "         INDEXW is INTEGER array, dimension (N)",
       "         The indices of the eigenvalues within each block (submatrix);",
       "         for example, INDEXW(i)= j and IBLOCK(i)=k imply that the",
       "         i-th eigenvalue W(i) is the j-th eigenvalue in block k."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  some or all of the eigenvalues failed to converge or",
       "               were not computed:",
       "               =1 or 3: Bisection failed to converge for some",
       "                       eigenvalues; these eigenvalues are flagged by a",
       "                       negative block number.  The effect is that the",
       "                       eigenvalues may not be as accurate as the",
       "                       absolute and relative tolerances.  This is",
       "                       generally caused by unexpectedly inaccurate",
       "                       arithmetic.",
       "               =2 or 3: RANGE='I' only: Not all of the eigenvalues",
       "                       IL:IU were found.",
       "                       Effect: M < IU+1-IL",
       "                       Cause:  non-monotonic arithmetic, causing the",
       "                               Sturm sequence to be non-monotonic.",
       "                       Cure:   recalculate, using RANGE='A', and pick",
       "                               out eigenvalues IL:IU.  In some cases,",
       "                               increasing the PARAMETER \"FUDGE\" may",
       "                               make things work.",
       "               = 4:    RANGE='I', and the Gershgorin interval",
       "                       initially used was too small.  No eigenvalues",
       "                       were computed.",
       "                       Probable cause: your machine has sloppy",
       "                                       floating-point arithmetic.",
       "                       Cure: Increase the PARAMETER \"FUDGE\",",
       "                             recompile, and try again."]}},
 "zgelqt"=>
  {"summary"=>
    ["ZGELQT computes a blocked LQ factorization of a complex M-by-N matrix A",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.  MIN(M,N) >= MB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the M-by-MIN(M,N) lower trapezoidal matrix L (L is",
       "         lower triangular if M <= N); the elements above the diagonal",
       "         are the rows of V."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,MIN(M,N))",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (MB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slapll"=>
  {"summary"=>
    ["Given two column vectors X and Y, let",
     "                     A = ( X Y ).",
     "The subroutine first computes the QR factorization of A = Q*R,",
     "and then computes the SVD of the 2-by-2 upper triangular matrix R.",
     "The smaller singular value of R is returned in SSMIN, which is used",
     "as the measurement of the linear dependency of the vectors X and Y."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The length of the vectors X and Y."],
     "X"=>
      ["[in,out]",
       "         X is REAL array,",
       "                        dimension (1+(N-1)*INCX)",
       "         On entry, X contains the N-vector X.",
       "         On exit, X is overwritten."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array,",
       "                        dimension (1+(N-1)*INCY)",
       "         On entry, Y contains the N-vector Y.",
       "         On exit, Y is overwritten."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between successive elements of Y. INCY > 0."],
     "SSMIN"=>
      ["[out]",
       "         SSMIN is REAL",
       "         The smallest singular value of the N-by-2 matrix A = ( X Y )."]}},
 "spttrs"=>
  {"summary"=>
    ["SPTTRS solves a tridiagonal system of the form",
     "   A * X = B",
     "using the L*D*L**T factorization of A computed by SPTTRF.  D is a",
     "diagonal matrix specified in the vector D, L is a unit bidiagonal",
     "matrix whose subdiagonal is specified in the vector E, and X and B",
     "are N by NRHS matrices."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         L*D*L**T factorization of A."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of the unit bidiagonal factor",
       "         L from the L*D*L**T factorization of A.  E can also be regarded",
       "         as the superdiagonal of the unit bidiagonal factor U from the",
       "         factorization A = U**T*D*U."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side vectors B for the system of",
       "         linear equations.",
       "         On exit, the solution vectors, X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "csytrf"=>
  {"summary"=>
    ["CSYTRF computes the factorization of a complex symmetric matrix A",
     "using the Bunch-Kaufman diagonal pivoting method.  The form of the",
     "factorization is",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "         interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "         If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and",
       "         columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "         is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =",
       "         IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were",
       "         interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "slaed6"=>
  {"summary"=>
    ["SLAED6 computes the positive or negative root (closest to the origin)",
     "of",
     "                 z(1)        z(2)        z(3)",
     "f(x) =   rho + --------- + ---------- + ---------",
     "                d(1)-x      d(2)-x      d(3)-x",
     "It is assumed that",
     "      if ORGATI = .true. the root is between d(2) and d(3);",
     "      otherwise it is between d(1) and d(2)",
     "This routine will be called by SLAED4 when necessary. In most cases,",
     "the root sought is the smallest in magnitude, though it might not be",
     "in some extremely rare situations."],
   "param"=>
    {"KNITER"=>
      ["[in]",
       "         KNITER is INTEGER",
       "              Refer to SLAED4 for its significance."],
     "ORGATI"=>
      ["[in]",
       "         ORGATI is LOGICAL",
       "              If ORGATI is true, the needed root is between d(2) and",
       "              d(3); otherwise it is between d(1) and d(2).  See",
       "              SLAED4 for further details."],
     "RHO"=>
      ["[in]",
       "         RHO is REAL",
       "              Refer to the equation f(x) above."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (3)",
       "              D satisfies d(1) < d(2) < d(3)."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension (3)",
       "              Each of the elements in z must be positive."],
     "FINIT"=>
      ["[in]",
       "         FINIT is REAL",
       "              The value of f at 0. It is more accurate than the one",
       "              evaluated inside this routine (if someone wants to do",
       "              so)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL",
       "              The root of the equation f(x)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "              = 0: successful exit",
       "              > 0: if INFO = 1, failure to converge"]}},
 "cgecon"=>
  {"summary"=>
    ["CGECON estimates the reciprocal of the condition number of a general",
     "complex matrix A, in either the 1-norm or the infinity-norm, using",
     "the LU factorization computed by CGETRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by CGETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cpoequ"=>
  {"summary"=>
    ["CPOEQU computes row and column scalings intended to equilibrate a",
     "Hermitian positive definite matrix A and reduce its condition number",
     "(with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The N-by-N Hermitian positive definite matrix whose scaling",
       "         factors are to be computed.  Only the diagonal elements of A",
       "         are referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is REAL",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "dlaed5"=>
  {"summary"=>
    ["This subroutine computes the I-th eigenvalue of a symmetric rank-one",
     "modification of a 2-by-2 diagonal matrix",
     "           diag( D )  +  RHO * Z * transpose(Z) .",
     "The diagonal elements in the array D are assumed to satisfy",
     "           D(i) < D(j)  for  i < j .",
     "We also assume RHO > 0 and that the Euclidean norm of the vector",
     "Z is one."],
   "param"=>
    {"I"=>
      ["[in]",
       "         I is INTEGER",
       "        The index of the eigenvalue to be computed.  I = 1 or I = 2."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (2)",
       "        The original eigenvalues.  We assume D(1) < D(2)."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension (2)",
       "        The components of the updating vector."],
     "DELTA"=>
      ["[out]",
       "         DELTA is DOUBLE PRECISION array, dimension (2)",
       "        The vector DELTA contains the information necessary",
       "        to construct the eigenvectors."],
     "RHO"=>
      ["[in]",
       "         RHO is DOUBLE PRECISION",
       "        The scalar in the symmetric updating formula."],
     "DLAM"=>
      ["[out]",
       "         DLAM is DOUBLE PRECISION",
       "        The computed lambda_I, the I-th updated eigenvalue."]}},
 "zgtsv"=>
  {"summary"=>
    ["ZGTSV  solves the equation",
     "   A*X = B,",
     "where A is an N-by-N tridiagonal matrix, by Gaussian elimination with",
     "partial pivoting.",
     "Note that the equation  A**T *X = B  may be solved by interchanging the",
     "order of the arguments DU and DL."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in,out]",
       "         DL is COMPLEX*16 array, dimension (N-1)",
       "         On entry, DL must contain the (n-1) subdiagonal elements of",
       "         A.",
       "         On exit, DL is overwritten by the (n-2) elements of the",
       "         second superdiagonal of the upper triangular matrix U from",
       "         the LU factorization of A, in DL(1), ..., DL(n-2)."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX*16 array, dimension (N)",
       "         On entry, D must contain the diagonal elements of A.",
       "         On exit, D is overwritten by the n diagonal elements of U."],
     "DU"=>
      ["[in,out]",
       "         DU is COMPLEX*16 array, dimension (N-1)",
       "         On entry, DU must contain the (n-1) superdiagonal elements",
       "         of A.",
       "         On exit, DU is overwritten by the (n-1) elements of the first",
       "         superdiagonal of U."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero, and the solution",
       "               has not been computed.  The factorization has not been",
       "               completed unless i = N."]}},
 "dbdsqr"=>
  {"summary"=>
    ["DBDSQR computes the singular values and, optionally, the right and/or",
     "left singular vectors from the singular value decomposition (SVD) of",
     "a real N-by-N (upper or lower) bidiagonal matrix B using the implicit",
     "zero-shift QR algorithm.  The SVD of B has the form",
     "   B = Q * S * P**T",
     "where S is the diagonal matrix of singular values, Q is an orthogonal",
     "matrix of left singular vectors, and P is an orthogonal matrix of",
     "right singular vectors.  If left singular vectors are requested, this",
     "subroutine actually returns U*Q instead of Q, and, if right singular",
     "vectors are requested, this subroutine returns P**T*VT instead of",
     "P**T, for given real input matrices U and VT.  When U and VT are the",
     "orthogonal matrices that reduce a general matrix A to bidiagonal",
     "form:  A = U*B*VT, as computed by DGEBRD, then",
     "   A = (U*Q) * S * (P**T*VT)",
     "is the SVD of A.  Optionally, the subroutine may also compute Q**T*C",
     "for a given real input matrix C.",
     "See \"Computing  Small Singular Values of Bidiagonal Matrices With",
     "Guaranteed High Relative Accuracy,\" by J. Demmel and W. Kahan,",
     "LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11,",
     "no. 5, pp. 873-912, Sept 1990) and",
     "\"Accurate singular values and differential qd algorithms,\" by",
     "B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics",
     "Department, University of California at Berkeley, July 1992",
     "for a detailed description of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  B is upper bidiagonal;",
       "         = 'L':  B is lower bidiagonal."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix B.  N >= 0."],
     "NCVT"=>
      ["[in]",
       "         NCVT is INTEGER",
       "         The number of columns of the matrix VT. NCVT >= 0."],
     "NRU"=>
      ["[in]",
       "         NRU is INTEGER",
       "         The number of rows of the matrix U. NRU >= 0."],
     "NCC"=>
      ["[in]",
       "         NCC is INTEGER",
       "         The number of columns of the matrix C. NCC >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the bidiagonal matrix B.",
       "         On exit, if INFO=0, the singular values of B in decreasing",
       "         order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the N-1 offdiagonal elements of the bidiagonal",
       "         matrix B.",
       "         On exit, if INFO = 0, E is destroyed; if INFO > 0, D and E",
       "         will contain the diagonal and superdiagonal elements of a",
       "         bidiagonal matrix orthogonally equivalent to the one given",
       "         as input."],
     "VT"=>
      ["[in,out]",
       "         VT is DOUBLE PRECISION array, dimension (LDVT, NCVT)",
       "         On entry, an N-by-NCVT matrix VT.",
       "         On exit, VT is overwritten by P**T * VT.",
       "         Not referenced if NCVT = 0."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.",
       "         LDVT >= max(1,N) if NCVT > 0; LDVT >= 1 if NCVT = 0."],
     "U"=>
      ["[in,out]",
       "         U is DOUBLE PRECISION array, dimension (LDU, N)",
       "         On entry, an NRU-by-N matrix U.",
       "         On exit, U is overwritten by U * Q.",
       "         Not referenced if NRU = 0."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= max(1,NRU)."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC, NCC)",
       "         On entry, an N-by-NCC matrix C.",
       "         On exit, C is overwritten by Q**T * C.",
       "         Not referenced if NCC = 0."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.",
       "         LDC >= max(1,N) if NCC > 0; LDC >=1 if NCC = 0."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  If INFO = -i, the i-th argument had an illegal value",
       "         > 0:",
       "            if NCVT = NRU = NCC = 0,",
       "               = 1, a split was marked by a positive value in E",
       "               = 2, current block of Z not diagonalized after 30*N",
       "                    iterations (in inner while loop)",
       "               = 3, termination criterion of outer while loop not met",
       "                    (program created more than N unreduced blocks)",
       "            else NCVT = NRU = NCC = 0,",
       "                  the algorithm did not converge; D and E contain the",
       "                  elements of a bidiagonal matrix which is orthogonally",
       "                  similar to the input matrix B;  if INFO = i, i",
       "                  elements of E have not converged to zero."]}},
 "cla_geamv"=>
  {"summary"=>
    ["CLA_GEAMV  performs one of the matrix-vector operations",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "   or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "m by n matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is INTEGER",
       "          On entry, TRANS specifies the operation to be performed as",
       "          follows:",
       "            BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)",
       "            BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "            BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of the matrix A.",
       "          M must be at least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is REAL",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,n)",
       "          Before entry, the leading m by n part of the array A must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, m ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension",
       "          ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is REAL",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array, dimension",
       "          ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit.",
       " Level 2 Blas routine."]}},
 "dgecon"=>
  {"summary"=>
    ["DGECON estimates the reciprocal of the condition number of a general",
     "real matrix A, in either the 1-norm or the infinity-norm, using",
     "the LU factorization computed by DGETRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by DGETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sormrq"=>
  {"summary"=>
    ["SORMRQ overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by SGERQF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         SGERQF in the last k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGERQF."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgbrfs"=>
  {"summary"=>
    ["SGBRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is banded, and provides",
     "error bounds and backward error estimates for the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The original band matrix A, stored in rows 1 to KL+KU+1.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is REAL array, dimension (LDAFB,N)",
       "         Details of the LU factorization of the band matrix A, as",
       "         computed by SGBTRF.  U is stored as an upper triangular band",
       "         matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and",
       "         the multipliers used during the factorization are stored in",
       "         rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "         The leading dimension of the array AFB.  LDAFB >= 2*KL*KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from SGBTRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by SGBTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zggev3"=>
  {"summary"=>
    ["ZGGEV3 computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, and optionally, the left and/or",
     "right generalized eigenvectors.",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right generalized eigenvector v(j) corresponding to the",
     "generalized eigenvalue lambda(j) of (A,B) satisfies",
     "             A * v(j) = lambda(j) * B * v(j).",
     "The left generalized eigenvector u(j) corresponding to the",
     "generalized eigenvalues lambda(j) of (A,B) satisfies",
     "             u(j)**H * A = lambda(j) * u(j)**H * B",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX*16 array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX*16 array, dimension (N)",
       "         On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the",
       "         generalized eigenvalues.",
       "         Note: the quotients ALPHA(j)/BETA(j) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio alpha/beta.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is COMPLEX*16 array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left generalized eigenvectors u(j) are",
       "         stored one after another in the columns of VL, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is COMPLEX*16 array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right generalized eigenvectors v(j) are",
       "         stored one after another in the columns of VR, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (8*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         =1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHA(j) and BETA(j) should be",
       "               correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other then QZ iteration failed in DHGEQZ,",
       "               =N+2: error return from DTGEVC."]}},
 "dlapmt"=>
  {"summary"=>
    ["DLAPMT rearranges the columns of the M by N matrix X as specified",
     "by the permutation K(1),K(2),...,K(N) of the integers 1,...,N.",
     "If FORWRD = .TRUE.,  forward permutation:",
     "     X(*,K(J)) is moved X(*,J) for J = 1,2,...,N.",
     "If FORWRD = .FALSE., backward permutation:",
     "     X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N."],
   "param"=>
    {"FORWRD"=>
      ["[in]",
       "         FORWRD is LOGICAL",
       "         = .TRUE., forward permutation",
       "         = .FALSE., backward permutation"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix X. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix X. N >= 0."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,N)",
       "         On entry, the M by N matrix X.",
       "         On exit, X contains the permuted matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X, LDX >= MAX(1,M)."],
     "K"=>
      ["[in,out]",
       "         K is INTEGER array, dimension (N)",
       "         On entry, K contains the permutation vector. K is used as",
       "         internal workspace, but reset to its original value on",
       "         output."]}},
 "zungr2"=>
  {"summary"=>
    ["ZUNGR2 generates an m by n complex matrix Q with orthonormal rows,",
     "which is defined as the last m rows of a product of k elementary",
     "reflectors of order n",
     "      Q  =  H(1)**H H(2)**H . . . H(k)**H",
     "as returned by ZGERQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the (m-k+i)-th row must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by ZGERQF in the last k rows of its array argument",
       "         A.",
       "         On exit, the m-by-n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGERQF."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "zherfs"=>
  {"summary"=>
    ["ZHERFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian indefinite, and",
     "provides error bounds and backward error estimates for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The Hermitian matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "         The factored form of the matrix A.  AF contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**H or",
       "         A = L*D*L**H as computed by ZHETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHETRF."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by ZHETRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dggsvp3"=>
  {"summary"=>
    ["DGGSVP3 computes orthogonal matrices U, V and Q such that",
     "                   N-K-L  K    L",
     " U**T*A*Q =     K ( 0    A12  A13 )  if M-K-L >= 0;",
     "                L ( 0     0   A23 )",
     "            M-K-L ( 0     0    0  )",
     "                 N-K-L  K    L",
     "        =     K ( 0    A12  A13 )  if M-K-L < 0;",
     "            M-K ( 0     0   A23 )",
     "                 N-K-L  K    L",
     " V**T*B*Q =   L ( 0     0   B13 )",
     "            P-L ( 0     0    0  )",
     "where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular",
     "upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,",
     "otherwise A23 is (M-K)-by-L upper trapezoidal.  K+L = the effective",
     "numerical rank of the (M+P)-by-N matrix (A**T,B**T)**T.",
     "This decomposition is the preprocessing step for computing the",
     "Generalized Singular Value Decomposition (GSVD), see subroutine",
     "DGGSVD3."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  Orthogonal matrix U is computed;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  Orthogonal matrix V is computed;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Orthogonal matrix Q is computed;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A contains the triangular (or trapezoidal) matrix",
       "         described in the Purpose section."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, B contains the triangular matrix described in",
       "         the Purpose section."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TOLA"=>["[in]", "         TOLA is DOUBLE PRECISION"],
     "TOLB"=>
      ["[in]",
       "         TOLB is DOUBLE PRECISION",
       "         TOLA and TOLB are the thresholds to determine the effective",
       "         numerical rank of matrix B and a subblock of A. Generally,",
       "         they are set to",
       "            TOLA = MAX(M,N)*norm(A)*MACHEPS,",
       "            TOLB = MAX(P,N)*norm(B)*MACHEPS.",
       "         The size of TOLA and TOLB may affect the size of backward",
       "         errors of the decomposition."],
     "K"=>["[out]", "         K is INTEGER"],
     "L"=>
      ["[out]",
       "         L is INTEGER",
       "         On exit, K and L specify the dimension of the subblocks",
       "         described in Purpose section.",
       "         K + L = effective numerical rank of (A**T,B**T)**T."],
     "U"=>
      ["[out]",
       "         U is DOUBLE PRECISION array, dimension (LDU,M)",
       "         If JOBU = 'U', U contains the orthogonal matrix U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[out]",
       "         V is DOUBLE PRECISION array, dimension (LDV,P)",
       "         If JOBV = 'V', V contains the orthogonal matrix V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         If JOBQ = 'Q', Q contains the orthogonal matrix Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "TAU"=>["[out]", "         TAU is DOUBLE PRECISION array, dimension (N)"],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "cpbtrf"=>
  {"summary"=>
    ["CPBTRF computes the Cholesky factorization of a complex Hermitian",
     "positive definite band matrix A.",
     "The factorization has the form",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H*U or A = L*L**H of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "zgesv"=>
  {"summary"=>
    ["ZGESV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N matrix and X and B are N-by-NRHS matrices.",
     "The LU decomposition with partial pivoting and row interchanges is",
     "used to factor A as",
     "   A = P * L * U,",
     "where P is a permutation matrix, L is unit lower triangular, and U is",
     "upper triangular.  The factored form of A is then used to solve the",
     "system of equations A * X = B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the N-by-N coefficient matrix A.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices that define the permutation matrix P;",
       "         row i of the matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS matrix of right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero.  The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, so the solution could not be computed."]}},
 "zpttrs"=>
  {"summary"=>
    ["ZPTTRS solves a tridiagonal system of the form",
     "   A * X = B",
     "using the factorization A = U**H *D* U or A = L*D*L**H computed by ZPTTRF.",
     "D is a diagonal matrix specified in the vector D, U (or L) is a unit",
     "bidiagonal matrix whose superdiagonal (subdiagonal) is specified in",
     "the vector E, and X and B are N by NRHS matrices."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the form of the factorization and whether the",
       "         vector E is the superdiagonal of the upper bidiagonal factor",
       "         U or the subdiagonal of the lower bidiagonal factor L.",
       "         = 'U':  A = U**H *D*U, E is the superdiagonal of U",
       "         = 'L':  A = L*D*L**H, E is the subdiagonal of L"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the diagonal matrix D from the",
       "         factorization A = U**H *D*U or A = L*D*L**H."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N-1)",
       "         If UPLO = 'U', the (n-1) superdiagonal elements of the unit",
       "         bidiagonal factor U from the factorization A = U**H*D*U.",
       "         If UPLO = 'L', the (n-1) subdiagonal elements of the unit",
       "         bidiagonal factor L from the factorization A = L*D*L**H."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side vectors B for the system of",
       "         linear equations.",
       "         On exit, the solution vectors, X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "ssytri"=>
  {"summary"=>
    ["SSYTRI computes the inverse of a real symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "SSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by SSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by SSYTRF."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "zgelsy"=>
  {"summary"=>
    ["ZGELSY computes the minimum-norm solution to a complex linear least",
     "squares problem:",
     "    minimize || A * X - B ||",
     "using a complete orthogonal factorization of A.  A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X.",
     "The routine first computes a QR factorization with column pivoting:",
     "    A * P = Q * [ R11 R12 ]",
     "                [  0  R22 ]",
     "with R11 defined as the largest leading submatrix whose estimated",
     "condition number is less than 1/RCOND.  The order of R11, RANK,",
     "is the effective rank of A.",
     "Then, R22 is considered to be negligible, and R12 is annihilated",
     "by unitary transformations from the right, arriving at the",
     "complete orthogonal factorization:",
     "   A * P = Q * [ T11 0 ] * Z",
     "               [  0  0 ]",
     "The minimum-norm solution is then",
     "   X = P * Z**H [ inv(T11)*Q1**H*B ]",
     "                [        0         ]",
     "where Q1 consists of the first RANK columns of Q.",
     "This routine is basically identical to the original xGELSX except",
     "three differences:",
     "  o The permutation of matrix B (the right hand side) is faster and",
     "    more simple.",
     "  o The call to the subroutine xGEQPF has been substituted by the",
     "    the call to the subroutine xGEQP3. This subroutine is a Blas-3",
     "    version of the QR factorization with column pivoting.",
     "  o Matrix B (the right hand side) is updated with Blas-3."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of",
       "         columns of matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A has been overwritten by details of its",
       "         complete orthogonal factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,M,N)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(i) .ne. 0, the i-th column of A is permuted",
       "         to the front of AP, otherwise column i is a free column.",
       "         On exit, if JPVT(i) = k, then the i-th column of A*P",
       "         was the k-th column of A."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "         RCOND is used to determine the effective rank of A, which",
       "         is defined as the order of the largest leading triangular",
       "         submatrix R11 in the QR factorization with pivoting of A,",
       "         whose estimated condition number < 1/RCOND."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the order of the submatrix",
       "         R11.  This is the same as the order of the submatrix T11",
       "         in the complete orthogonal factorization of A."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         The unblocked strategy requires that:",
       "           LWORK >= MN + MAX( 2*MN, N+1, MN+NRHS )",
       "         where MN = min(M,N).",
       "         The block algorithm requires that:",
       "           LWORK >= MN + MAX( 2*MN, NB*(N+1), MN+MN*NB, MN+NB*NRHS )",
       "         where NB is an upper bound on the blocksize returned",
       "         by ILAENV for the routines ZGEQP3, ZTZRZF, CTZRQF, ZUNMQR,",
       "         and ZUNMRZ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "cla_porcond_c"=>
  {"summary"=>
    ["   CLA_PORCOND_C Computes the infinity norm condition number of",
     "   op(A) * inv(diag(C)) where C is a REAL vector"],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**H*U or A = L*L**H, as computed by CPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The vector C in the formula op(A) * inv(diag(C))."],
     "CAPPLY"=>
      ["[in]",
       "         CAPPLY is LOGICAL",
       "    If .TRUE. then access the vector C in the formula above."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is REAL array, dimension (N).",
       "    Workspace."]}},
 "sbbcsd"=>
  {"summary"=>
    ["SBBCSD computes the CS decomposition of an orthogonal matrix in",
     "bidiagonal-block form,",
     "    [ B11 | B12 0  0 ]",
     "    [  0  |  0 -I  0 ]",
     "X = [----------------]",
     "    [ B21 | B22 0  0 ]",
     "    [  0  |  0  0  I ]",
     "                              [  C | -S  0  0 ]",
     "                  [ U1 |    ] [  0 |  0 -I  0 ] [ V1 |    ]**T",
     "                = [---------] [---------------] [---------]   .",
     "                  [    | U2 ] [  S |  C  0  0 ] [    | V2 ]",
     "                              [  0 |  0  0  I ]",
     "X is M-by-M, its top-left block is P-by-Q, and Q must be no larger",
     "than P, M-P, or M-Q. (If Q is not the smallest index, then X must be",
     "transposed and/or permuted. This can be done in constant time using",
     "the TRANS and SIGNS options. See SORCSD for details.)",
     "The bidiagonal matrices B11, B12, B21, and B22 are represented",
     "implicitly by angles THETA(1:Q) and PHI(1:Q-1).",
     "The orthogonal matrices U1, U2, V1T, and V2T are input/output.",
     "The input matrices are pre- or post-multiplied by the appropriate",
     "singular vector matrices."],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is updated;",
       "         otherwise:  U1 is not updated."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is updated;",
       "         otherwise:  U2 is not updated."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is updated;",
       "         otherwise:  V1T is not updated."],
     "JOBV2T"=>
      ["[in]",
       "         JOBV2T is CHARACTER",
       "         = 'Y':      V2T is updated;",
       "         otherwise:  V2T is not updated."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X, the orthogonal matrix in",
       "         bidiagonal-block form."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in the top-left block of X. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in the top-left block of X.",
       "         0 <= Q <= MIN(P,M-P,M-Q)."],
     "THETA"=>
      ["[in,out]",
       "         THETA is REAL array, dimension (Q)",
       "         On entry, the angles THETA(1),...,THETA(Q) that, along with",
       "         PHI(1), ...,PHI(Q-1), define the matrix in bidiagonal-block",
       "         form. On exit, the angles whose cosines and sines define the",
       "         diagonal blocks in the CS decomposition."],
     "PHI"=>
      ["[in,out]",
       "         PHI is REAL array, dimension (Q-1)",
       "         The angles PHI(1),...,PHI(Q-1) that, along with THETA(1),...,",
       "         THETA(Q), define the matrix in bidiagonal-block form."],
     "U1"=>
      ["[in,out]",
       "         U1 is REAL array, dimension (LDU1,P)",
       "         On entry, a P-by-P matrix. On exit, U1 is postmultiplied",
       "         by the left singular vector matrix common to [ B11 ; 0 ] and",
       "         [ B12 0 0 ; 0 -I 0 0 ]."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of the array U1, LDU1 >= MAX(1,P)."],
     "U2"=>
      ["[in,out]",
       "         U2 is REAL array, dimension (LDU2,M-P)",
       "         On entry, an (M-P)-by-(M-P) matrix. On exit, U2 is",
       "         postmultiplied by the left singular vector matrix common to",
       "         [ B21 ; 0 ] and [ B22 0 0 ; 0 0 I ]."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of the array U2, LDU2 >= MAX(1,M-P)."],
     "V1T"=>
      ["[in,out]",
       "         V1T is REAL array, dimension (LDV1T,Q)",
       "         On entry, a Q-by-Q matrix. On exit, V1T is premultiplied",
       "         by the transpose of the right singular vector",
       "         matrix common to [ B11 ; 0 ] and [ B21 ; 0 ]."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of the array V1T, LDV1T >= MAX(1,Q)."],
     "V2T"=>
      ["[in,out]",
       "         V2T is REAL array, dimenison (LDV2T,M-Q)",
       "         On entry, an (M-Q)-by-(M-Q) matrix. On exit, V2T is",
       "         premultiplied by the transpose of the right",
       "         singular vector matrix common to [ B12 0 0 ; 0 -I 0 ] and",
       "         [ B22 0 0 ; 0 0 I ]."],
     "LDV2T"=>
      ["[in]",
       "         LDV2T is INTEGER",
       "         The leading dimension of the array V2T, LDV2T >= MAX(1,M-Q)."],
     "B11D"=>
      ["[out]",
       "         B11D is REAL array, dimension (Q)",
       "         When SBBCSD converges, B11D contains the cosines of THETA(1),",
       "         ..., THETA(Q). If SBBCSD fails to converge, then B11D",
       "         contains the diagonal of the partially reduced top-left",
       "         block."],
     "B11E"=>
      ["[out]",
       "         B11E is REAL array, dimension (Q-1)",
       "         When SBBCSD converges, B11E contains zeros. If SBBCSD fails",
       "         to converge, then B11E contains the superdiagonal of the",
       "         partially reduced top-left block."],
     "B12D"=>
      ["[out]",
       "         B12D is REAL array, dimension (Q)",
       "         When SBBCSD converges, B12D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If SBBCSD fails to converge, then",
       "         B12D contains the diagonal of the partially reduced top-right",
       "         block."],
     "B12E"=>
      ["[out]",
       "         B12E is REAL array, dimension (Q-1)",
       "         When SBBCSD converges, B12E contains zeros. If SBBCSD fails",
       "         to converge, then B12E contains the subdiagonal of the",
       "         partially reduced top-right block."],
     "B21D"=>
      ["[out]",
       "         B21D is REAL array, dimension (Q)",
       "         When SBBCSD converges, B21D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If SBBCSD fails to converge, then",
       "         B21D contains the diagonal of the partially reduced bottom-left",
       "         block."],
     "B21E"=>
      ["[out]",
       "         B21E is REAL array, dimension (Q-1)",
       "         When SBBCSD converges, B21E contains zeros. If SBBCSD fails",
       "         to converge, then B21E contains the subdiagonal of the",
       "         partially reduced bottom-left block."],
     "B22D"=>
      ["[out]",
       "         B22D is REAL array, dimension (Q)",
       "         When SBBCSD converges, B22D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If SBBCSD fails to converge, then",
       "         B22D contains the diagonal of the partially reduced bottom-right",
       "         block."],
     "B22E"=>
      ["[out]",
       "         B22E is REAL array, dimension (Q-1)",
       "         When SBBCSD converges, B22E contains zeros. If SBBCSD fails",
       "         to converge, then B22E contains the subdiagonal of the",
       "         partially reduced bottom-right block."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= MAX(1,8*Q).",
       "         If LWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the WORK array,",
       "         returns this value as the first entry of the work array, and",
       "         no error message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if SBBCSD did not converge, INFO specifies the number",
       "               of nonzero entries in PHI, and B11D, B11E, etc.,",
       "               contain the partially reduced matrix."]}},
 "zpoequb"=>
  {"summary"=>
    ["ZPOEQUB computes row and column scalings intended to equilibrate a",
     "Hermitian positive definite matrix A and reduce its condition number",
     "(with respect to the two-norm).  S contains the scale factors,",
     "S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with",
     "elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This",
     "choice of S puts the condition number of B within a factor N of the",
     "smallest possible condition number over all possible diagonal",
     "scalings.",
     "This routine differs from ZPOEQU by restricting the scaling factors",
     "to a power of the radix.  Barring over- and underflow, scaling by",
     "these factors introduces no additional rounding errors.  However, the",
     "scaled diagonal entries are no longer approximately 1 but lie",
     "between sqrt(radix) and 1/sqrt(radix)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The N-by-N Hermitian positive definite matrix whose scaling",
       "         factors are to be computed.  Only the diagonal elements of A",
       "         are referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is DOUBLE PRECISION",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "zlatrd"=>
  {"summary"=>
    ["ZLATRD reduces NB rows and columns of a complex Hermitian matrix A to",
     "Hermitian tridiagonal form by a unitary similarity",
     "transformation Q**H * A * Q, and returns the matrices V and W which are",
     "needed to apply the transformation to the unreduced part of A.",
     "If UPLO = 'U', ZLATRD reduces the last NB rows and columns of a",
     "matrix, of which the upper triangle is supplied;",
     "if UPLO = 'L', ZLATRD reduces the first NB rows and columns of a",
     "matrix, of which the lower triangle is supplied.",
     "This is an auxiliary routine called by ZHETRD."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U': Upper triangular",
       "         = 'L': Lower triangular"],
     "N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The number of rows and columns to be reduced."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit:",
       "         if UPLO = 'U', the last NB columns have been reduced to",
       "           tridiagonal form, with the diagonal elements overwriting",
       "           the diagonal elements of A; the elements above the diagonal",
       "           with the array TAU, represent the unitary matrix Q as a",
       "           product of elementary reflectors;",
       "         if UPLO = 'L', the first NB columns have been reduced to",
       "           tridiagonal form, with the diagonal elements overwriting",
       "           the diagonal elements of A; the elements below the diagonal",
       "           with the array TAU, represent the  unitary matrix Q as a",
       "           product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         If UPLO = 'U', E(n-nb:n-1) contains the superdiagonal",
       "         elements of the last NB columns of the reduced matrix;",
       "         if UPLO = 'L', E(1:nb) contains the subdiagonal elements of",
       "         the first NB columns of the reduced matrix."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors, stored in",
       "         TAU(n-nb:n-1) if UPLO = 'U', and in TAU(1:nb) if UPLO = 'L'.",
       "         See Further Details."],
     "W"=>
      ["[out]",
       "         W is COMPLEX*16 array, dimension (LDW,NB)",
       "         The n-by-nb matrix W required to update the unreduced part",
       "         of A."],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W. LDW >= max(1,N)."]}},
 "zlarfgp"=>
  {"summary"=>
    ["ZLARFGP generates a complex elementary reflector H of order n, such",
     "that",
     "      H**H * ( alpha ) = ( beta ),   H**H * H = I.",
     "             (   x   )   (   0  )",
     "where alpha and beta are scalars, beta is real and non-negative, and",
     "x is an (n-1)-element complex vector.  H is represented in the form",
     "      H = I - tau * ( 1 ) * ( 1 v**H ) ,",
     "                    ( v )",
     "where tau is a complex scalar and v is a complex (n-1)-element",
     "vector. Note that H is not hermitian.",
     "If the elements of x are all zero and alpha is real, then tau = 0",
     "and H is taken to be the unit matrix."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the elementary reflector."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is COMPLEX*16",
       "         On entry, the value alpha.",
       "         On exit, it is overwritten with the value beta."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension",
       "                        (1+(N-2)*abs(INCX))",
       "         On entry, the vector x.",
       "         On exit, it is overwritten with the vector v."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "TAU"=>
      ["[out]", "         TAU is COMPLEX*16", "         The value tau."]}},
 "cpstf2"=>
  {"summary"=>
    ["CPSTF2 computes the Cholesky factorization with complete",
     "pivoting of a complex Hermitian positive semidefinite matrix A.",
     "The factorization has the form",
     "   P**T * A * P = U**H * U ,  if UPLO = 'U',",
     "   P**T * A * P = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular, and",
     "P is stored as vector PIV.",
     "This algorithm does not attempt to check that A is positive",
     "semidefinite. This version of the algorithm calls level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization as above."],
     "PIV"=>
      ["[out]",
       "         PIV is INTEGER array, dimension (N)",
       "         PIV is such that the nonzero entries are P( PIV(K), K ) = 1."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The rank of A given by the number of steps the algorithm",
       "         completed."],
     "TOL"=>
      ["[in]",
       "         TOL is REAL",
       "         User defined tolerance. If TOL < 0, then N*U*MAX( A( K,K ) )",
       "         will be used. The algorithm terminates at the (K-1)st step",
       "         if the pivot <= TOL."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (2*N)",
       "         Work space."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         < 0: If INFO = -K, the K-th argument had an illegal value,",
       "         = 0: algorithm completed successfully, and",
       "         > 0: the matrix A is either rank deficient with computed rank",
       "              as returned in RANK, or is not positive semidefinite. See",
       "              Section 7 of LAPACK Working Note #161 for further",
       "              information."]}},
 "clahef_rk"=>
  {"summary"=>
    ["CLAHEF_RK computes a partial factorization of a complex Hermitian",
     "matrix A using the bounded Bunch-Kaufman (rook) diagonal",
     "pivoting method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**H U22**H )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**H L21**H )  if UPLO = 'L',",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "CLAHEF_RK is an auxiliary routine called by CHETRF_RK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the Hermitian block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,N-KB+1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,1:KB).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "W"=>["[out]", "         W is COMPLEX array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "zgeqlf"=>
  {"summary"=>
    ["ZGEQLF computes a QL factorization of a complex M-by-N matrix A:",
     "A = Q * L."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if m >= n, the lower triangle of the subarray",
       "         A(m-n+1:m,1:n) contains the N-by-N lower triangular matrix L;",
       "         if m <= n, the elements on and below the (n-m)-th",
       "         superdiagonal contain the M-by-N lower trapezoidal matrix L;",
       "         the remaining elements, with the array TAU, represent the",
       "         unitary matrix Q as a product of elementary reflectors",
       "         (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cheevd_2stage"=>
  {"summary"=>
    ["CHEEVD_2STAGE computes all eigenvalues and, optionally, eigenvectors of a",
     "complex Hermitian matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  If eigenvectors are desired, it uses a",
     "divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + N+1",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + N+1",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least 2*N + N**2",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array,",
       "                                        dimension (LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK.",
       "         If N <= 1,                LRWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LRWORK must be at least N.",
       "         If JOBZ  = 'V' and N > 1, LRWORK must be at least",
       "                        1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If N <= 1,                LIWORK must be at least 1.",
       "         If JOBZ  = 'N' and N > 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i and JOBZ = 'N', then the algorithm failed",
       "               to converge; i off-diagonal elements of an intermediate",
       "               tridiagonal form did not converge to zero;",
       "               if INFO = i and JOBZ = 'V', then the algorithm failed",
       "               to compute an eigenvalue while working on the submatrix",
       "               lying in rows and columns INFO/(N+1) through",
       "               mod(INFO,N+1)."]}},
 "zlamtsqr"=>
  {"summary"=>
    ["     ZLAMTSQR overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**C * C       C * Q**C",
     "     where Q is a real orthogonal matrix defined as the product",
     "     of blocked elementary reflectors computed by tall skinny",
     "     QR factorization (ZLATSQR)"],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate Transpose, apply Q**C."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >=0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         N >= K >= 0;"],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.",
       "         MB > N. (must be the same as DLATSQR)"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         blockedelementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by DLATSQR in the first k columns of",
       "         its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension",
       "         ( N * Number of blocks(CEIL(M-K/MB-K)),",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "        (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N)*NB;",
       "         if SIDE = 'R', LWORK >= max(1,MB)*NB.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dtrtri"=>
  {"summary"=>
    ["DTRTRI computes the inverse of a real upper or lower triangular",
     "matrix A.",
     "This is the Level 3 BLAS version of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the triangular matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of the array A contains",
       "         the upper triangular matrix, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of the array A contains",
       "         the lower triangular matrix, and the strictly upper",
       "         triangular part of A is not referenced.  If DIAG = 'U', the",
       "         diagonal elements of A are also not referenced and are",
       "         assumed to be 1.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, A(i,i) is exactly zero.  The triangular",
       "              matrix is singular and its inverse can not be computed."]}},
 "cptsvx"=>
  {"summary"=>
    ["CPTSVX uses the factorization A = L*D*L**H to compute the solution",
     "to a complex system of linear equations A*X = B, where A is an",
     "N-by-N Hermitian positive definite tridiagonal matrix and X and B",
     "are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "dla_wwaddw"=>
  {"summary"=>
    ["   DLA_WWADDW adds a vector W into a doubled-single vector (X, Y).",
     "   This works for all extant IBM's hex and binary floating point",
     "   arithmetics, but not for decimal."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "           The length of vectors X, Y, and W."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (N)",
       "           The first part of the doubled-single accumulation vector."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension (N)",
       "           The second part of the doubled-single accumulation vector."],
     "W"=>
      ["[in]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "           The vector to be added."]}},
 "cgebrd"=>
  {"summary"=>
    ["CGEBRD reduces a general complex M-by-N matrix A to upper or lower",
     "bidiagonal form B by a unitary transformation: Q**H * A * P = B.",
     "If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N general matrix to be reduced.",
       "         On exit,",
       "         if m >= n, the diagonal and the first superdiagonal are",
       "           overwritten with the upper bidiagonal matrix B; the",
       "           elements below the diagonal, with the array TAUQ, represent",
       "           the unitary matrix Q as a product of elementary",
       "           reflectors, and the elements above the first superdiagonal,",
       "           with the array TAUP, represent the unitary matrix P as",
       "           a product of elementary reflectors;",
       "         if m < n, the diagonal and the first subdiagonal are",
       "           overwritten with the lower bidiagonal matrix B; the",
       "           elements below the first subdiagonal, with the array TAUQ,",
       "           represent the unitary matrix Q as a product of",
       "           elementary reflectors, and the elements above the diagonal,",
       "           with the array TAUP, represent the unitary matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (min(M,N)-1)",
       "         The off-diagonal elements of the bidiagonal matrix B:",
       "         if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;",
       "         if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is COMPLEX array dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix P. See Further Details."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,M,N).",
       "         For optimum performance LWORK >= (M+N)*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "claqsp"=>
  {"summary"=>
    ["CLAQSP equilibrates a symmetric matrix A using the scaling factors",
     "in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the equilibrated matrix:  diag(S) * A * diag(S), in",
       "         the same storage format as A."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is REAL",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "clacrm"=>
  {"summary"=>
    ["CLACRM performs a very simple matrix-matrix multiplication:",
     "         C := A * B,",
     "where A is M by N and complex; B is N by N and real;",
     "C is M by N and complex."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A and of the matrix C.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns and rows of the matrix B and",
       "         the number of columns of the matrix C.",
       "         N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, A contains the M by N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >=max(1,M)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, B contains the N by N matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >=max(1,N)."],
     "C"=>
      ["[out]",
       "         C is COMPLEX array, dimension (LDC, N)",
       "         On exit, C contains the M by N matrix C."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >=max(1,N)."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (2*M*N)"]}},
 "dtfsm"=>
  {"summary"=>
    ["Level 3 BLAS like routine for A in RFP Format.",
     "DTFSM  solves the matrix equation",
     "   op( A )*X = alpha*B  or  X*op( A ) = alpha*B",
     "where alpha is a scalar, X and B are m by n matrices, A is a unit, or",
     "non-unit,  upper or lower triangular matrix  and  op( A )  is one  of",
     "   op( A ) = A   or   op( A ) = A**T.",
     "A is in Rectangular Full Packed (RFP) Format.",
     "The matrix X is overwritten on B."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal Form of RFP A is stored;",
       "         = 'T':  The Transpose Form of RFP A is stored."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "          On entry, SIDE specifies whether op( A ) appears on the left",
       "          or right of X as follows:",
       "             SIDE = 'L' or 'l'   op( A )*X = alpha*B.",
       "             SIDE = 'R' or 'r'   X*op( A ) = alpha*B.",
       "          Unchanged on exit."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the RFP matrix A came from",
       "          an upper or lower triangular matrix as follows:",
       "          UPLO = 'U' or 'u' RFP A came from an upper triangular matrix",
       "          UPLO = 'L' or 'l' RFP A came from a  lower triangular matrix",
       "          Unchanged on exit."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "          On entry, TRANS  specifies the form of op( A ) to be used",
       "          in the matrix multiplication as follows:",
       "             TRANS  = 'N' or 'n'   op( A ) = A.",
       "             TRANS  = 'T' or 't'   op( A ) = A'.",
       "          Unchanged on exit."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "          On entry, DIAG specifies whether or not RFP A is unit",
       "          triangular as follows:",
       "             DIAG = 'U' or 'u'   A is assumed to be unit triangular.",
       "             DIAG = 'N' or 'n'   A is not assumed to be unit",
       "                                 triangular.",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of B. M must be at",
       "          least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of B.  N must be",
       "          at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "          On entry,  ALPHA specifies the scalar  alpha. When  alpha is",
       "          zero then  A is not referenced and  B need not be set before",
       "          entry.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (NT)",
       "          NT = N*(N+1)/2. On entry, the matrix A in RFP Format.",
       "          RFP Format is described by TRANSR, UPLO and N as follows:",
       "          If TRANSR='N' then RFP A is (0:N,0:K-1) when N is even;",
       "          K=N/2. RFP A is (0:N-1,0:K) when N is odd; K=N/2. If",
       "          TRANSR = 'T' then RFP is the transpose of RFP A as",
       "          defined when TRANSR = 'N'. The contents of RFP A are defined",
       "          by UPLO as follows: If UPLO = 'U' the RFP A contains the NT",
       "          elements of upper packed A either in normal or",
       "          transpose Format. If UPLO = 'L' the RFP A contains",
       "          the NT elements of lower packed A either in normal or",
       "          transpose Format. The LDA of RFP A is (N+1)/2 when",
       "          TRANSR = 'T'. When TRANSR is 'N' the LDA is N+1 when N is",
       "          even and is N when is odd.",
       "          See the Note below for more details. Unchanged on exit."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "          Before entry,  the leading  m by n part of the array  B must",
       "          contain  the  right-hand  side  matrix  B,  and  on exit  is",
       "          overwritten by the solution matrix  X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "          On entry, LDB specifies the first dimension of B as declared",
       "          in  the  calling  (sub)  program.   LDB  must  be  at  least",
       "          max( 1, m ).",
       "          Unchanged on exit."]}},
 "dgbsv"=>
  {"summary"=>
    ["DGBSV computes the solution to a real system of linear equations",
     "A * X = B, where A is a band matrix of order N with KL subdiagonals",
     "and KU superdiagonals, and X and B are N-by-NRHS matrices.",
     "The LU decomposition with partial pivoting and row interchanges is",
     "used to factor A as A = L * U, where L is a product of permutation",
     "and unit lower triangular matrices with KL subdiagonals, and U is",
     "upper triangular with KL+KU superdiagonals.  The factored form of A",
     "is then used to solve the system of equations A * X = B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of superdiagonals within the band of A.  KU >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the matrix A in band storage, in rows KL+1 to",
       "         2*KL+KU+1; rows 1 to KL of the array need not be set.",
       "         The j-th column of A is stored in the j-th column of the",
       "         array AB as follows:",
       "         AB(KL+KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+KL)",
       "         On exit, details of the factorization: U is stored as an",
       "         upper triangular band matrix with KL+KU superdiagonals in",
       "         rows 1 to KL+KU+1, and the multipliers used during the",
       "         factorization are stored in rows KL+KU+2 to 2*KL+KU+1.",
       "         See below for further details."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices that define the permutation matrix P;",
       "         row i of the matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero.  The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, and the solution has not been computed."]}},
 "dsteqr"=>
  {"summary"=>
    ["DSTEQR computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric tridiagonal matrix using the implicit QL or QR method.",
     "The eigenvectors of a full or band symmetric matrix can also be found",
     "if DSYTRD or DSPTRD or DSBTRD has been used to reduce this matrix to",
     "tridiagonal form."],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'V':  Compute eigenvalues and eigenvectors of the original",
       "                 symmetric matrix.  On entry, Z must contain the",
       "                 orthogonal matrix used to reduce the original matrix",
       "                 to tridiagonal form.",
       "         = 'I':  Compute eigenvalues and eigenvectors of the",
       "                 tridiagonal matrix.  Z is initialized to the identity",
       "                 matrix."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the diagonal elements of the tridiagonal matrix.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         On entry, if  COMPZ = 'V', then Z contains the orthogonal",
       "         matrix used in the reduction to tridiagonal form.",
       "         On exit, if INFO = 0, then if  COMPZ = 'V', Z contains the",
       "         orthonormal eigenvectors of the original symmetric matrix,",
       "         and if COMPZ = 'I', Z contains the orthonormal eigenvectors",
       "         of the symmetric tridiagonal matrix.",
       "         If COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         eigenvectors are desired, then  LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (max(1,2*N-2))",
       "         If COMPZ = 'N', then WORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  the algorithm has failed to find all the eigenvalues in",
       "               a total of 30*N iterations; if INFO = i, then i",
       "               elements of E have not converged to zero; on exit, D",
       "               and E contain the elements of a symmetric tridiagonal",
       "               matrix which is orthogonally similar to the original",
       "               matrix."]}},
 "dpstrf"=>
  {"summary"=>
    ["DPSTRF computes the Cholesky factorization with complete",
     "pivoting of a real symmetric positive semidefinite matrix A.",
     "The factorization has the form",
     "   P**T * A * P = U**T * U ,  if UPLO = 'U',",
     "   P**T * A * P = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular, and",
     "P is stored as vector PIV.",
     "This algorithm does not attempt to check that A is positive",
     "semidefinite. This version of the algorithm calls level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization as above."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "PIV"=>
      ["[out]",
       "         PIV is INTEGER array, dimension (N)",
       "         PIV is such that the nonzero entries are P( PIV(K), K ) = 1."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The rank of A given by the number of steps the algorithm",
       "         completed."],
     "TOL"=>
      ["[in]",
       "         TOL is DOUBLE PRECISION",
       "         User defined tolerance. If TOL < 0, then N*U*MAX( A(K,K) )",
       "         will be used. The algorithm terminates at the (K-1)st step",
       "         if the pivot <= TOL."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (2*N)",
       "         Work space."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         < 0: If INFO = -K, the K-th argument had an illegal value,",
       "         = 0: algorithm completed successfully, and",
       "         > 0: the matrix A is either rank deficient with computed rank",
       "              as returned in RANK, or is not positive semidefinite. See",
       "              Section 7 of LAPACK Working Note #161 for further",
       "              information."]}},
 "crot"=>
  {"summary"=>
    ["CROT   applies a plane rotation, where the cos (C) is real and the",
     "sin (S) is complex, and the vectors CX and CY are complex."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements in the vectors CX and CY."],
     "CX"=>
      ["[in,out]",
       "         CX is COMPLEX array, dimension (N)",
       "         On input, the vector X.",
       "         On output, CX is overwritten with C*X + S*Y."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of CY.  INCX <> 0."],
     "CY"=>
      ["[in,out]",
       "         CY is COMPLEX array, dimension (N)",
       "         On input, the vector Y.",
       "         On output, CY is overwritten with -CONJG(S)*X + C*Y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between successive values of CY.  INCX <> 0."],
     "C"=>["[in]", "         C is REAL"],
     "S"=>
      ["[in]",
       "         S is COMPLEX",
       "         C and S define a rotation",
       "            [  C          S  ]",
       "            [ -conjg(S)   C  ]",
       "         where C*C + S*CONJG(S) = 1.0."]}},
 "sormlq"=>
  {"summary"=>
    ["SORMLQ overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k) . . . H(2) H(1)",
     "as returned by SGELQF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         SGELQF in the first k rows of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is REAL array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by SGELQF."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chetrd_he2hb"=>
  {"summary"=>
    ["CHETRD_HE2HB reduces a complex Hermitian matrix A to complex Hermitian",
     "band-diagonal form AB by a unitary similarity transformation:",
     "Q**H * A * Q = AB."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the reduced matrix if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0.",
       "         The reduced matrix is stored in the array AB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the unitary",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the unitary matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AB"=>
      ["[out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On exit, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (N-KD)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension LWORK.",
       "         On exit, if INFO = 0, or if LWORK=-1, ",
       "         WORK(1) returns the size of LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK which should be calculated",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA.",
       "         LWORK_QUERY = N*KD + N*max(KD,FACTOPTNB) + 2*KD*KD",
       "         where FACTOPTNB is the blocking used by the QR or LQ",
       "         algorithm, usually FACTOPTNB=128 is a good choice otherwise",
       "         putting LWORK=-1 will provide the size of WORK."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chetrd"=>
  {"summary"=>
    ["CHETRD reduces a complex Hermitian matrix A to real symmetric",
     "tridiagonal form T by a unitary similarity transformation:",
     "Q**H * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the unitary",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the unitary matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= 1.",
       "         For optimum performance LWORK >= N*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dsyev_2stage"=>
  {"summary"=>
    ["DSYEV_2STAGE computes all eigenvalues and, optionally, eigenvectors of a",
     "real symmetric matrix A using the 2stage technique for",
     "the reduction to tridiagonal."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         orthonormal eigenvectors of the matrix A.",
       "         If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')",
       "         or the upper triangle (if UPLO='U') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension LWORK",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + 2*N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + 2*N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "slaqsb"=>
  {"summary"=>
    ["SLAQSB equilibrates a symmetric band matrix A using the scaling",
     "factors in the vector S."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**T*U or A = L*L**T of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension (N)",
       "         The scale factors for A."],
     "SCOND"=>
      ["[in]",
       "         SCOND is REAL",
       "         Ratio of the smallest S(i) to the largest S(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies whether or not equilibration was done.",
       "         = 'N':  No equilibration.",
       "         = 'Y':  Equilibration was done, i.e., A has been replaced by",
       "                 diag(S) * A * diag(S)."]}},
 "dsysvxx"=>
  {"summary"=>
    ["   DSYSVXX uses the diagonal pivoting factorization to compute the",
     "   solution to a double precision system of linear equations A * X = B, where A",
     "   is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. DSYSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   DSYSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   DSYSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what DSYSVXX would itself produce."],
   "param"=>nil},
 "cgesvx"=>
  {"summary"=>
    ["CGESVX uses the LU factorization to compute the solution to a complex",
     "system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N matrix and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "zlatdf"=>
  {"summary"=>
    ["ZLATDF computes the contribution to the reciprocal Dif-estimate",
     "by solving for x in Z * x = b, where b is chosen such that the norm",
     "of x is as large as possible. It is assumed that LU decomposition",
     "of Z has been computed by ZGETC2. On entry RHS = f holds the",
     "contribution from earlier solved sub-systems, and on return RHS = x.",
     "The factorization of Z returned by ZGETC2 has the form",
     "Z = P * L * U * Q, where P and Q are permutation matrices. L is lower",
     "triangular with unit diagonal elements and U is upper triangular."],
   "param"=>
    {"IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         IJOB = 2: First compute an approximative null-vector e",
       "             of Z using ZGECON, e is normalized and solve for",
       "             Zx = +-e - f with the sign giving the greater value of",
       "             2-norm(x).  About 5 times as expensive as Default.",
       "         IJOB .ne. 2: Local look ahead strategy where",
       "             all entries of the r.h.s. b is chosen as either +1 or",
       "             -1.  Default."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Z."],
     "Z"=>
      ["[in]",
       "         Z is COMPLEX*16 array, dimension (LDZ, N)",
       "         On entry, the LU part of the factorization of the n-by-n",
       "         matrix Z computed by ZGETC2:  Z = P * L * U * Q"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDA >= max(1, N)."],
     "RHS"=>
      ["[in,out]",
       "         RHS is COMPLEX*16 array, dimension (N).",
       "         On entry, RHS contains contributions from other subsystems.",
       "         On exit, RHS contains the solution of the subsystem with",
       "         entries according to the value of IJOB (see above)."],
     "RDSUM"=>
      ["[in,out]",
       "         RDSUM is DOUBLE PRECISION",
       "         On entry, the sum of squares of computed contributions to",
       "         the Dif-estimate under computation by ZTGSYL, where the",
       "         scaling factor RDSCAL (see below) has been factored out.",
       "         On exit, the corresponding sum of squares updated with the",
       "         contributions from the current sub-system.",
       "         If TRANS = 'T' RDSUM is not touched.",
       "         NOTE: RDSUM only makes sense when ZTGSY2 is called by CTGSYL."],
     "RDSCAL"=>
      ["[in,out]",
       "         RDSCAL is DOUBLE PRECISION",
       "         On entry, scaling factor used to prevent overflow in RDSUM.",
       "         On exit, RDSCAL is updated w.r.t. the current contributions",
       "         in RDSUM.",
       "         If TRANS = 'T', RDSCAL is not touched.",
       "         NOTE: RDSCAL only makes sense when ZTGSY2 is called by",
       "         ZTGSYL."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[in]",
       "         JPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."]}},
 "dlaed3"=>
  {"summary"=>
    ["DLAED3 finds the roots of the secular equation, as defined by the",
     "values in D, W, and RHO, between 1 and K.  It makes the",
     "appropriate calls to DLAED4 and then updates the eigenvectors by",
     "multiplying the matrix of eigenvectors of the pair of eigensystems",
     "being combined by the matrix of eigenvectors of the K-by-K system",
     "which is solved here.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of terms in the rational function to be solved by",
       "         DLAED4.  K >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows and columns in the Q matrix.",
       "         N >= K (deflation may result in N>K)."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         The location of the last eigenvalue in the leading submatrix.",
       "         min(1,N) <= N1 <= N/2."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         D(I) contains the updated eigenvalues for",
       "         1 <= I <= K."],
     "Q"=>
      ["[out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         Initially the first K columns are used as workspace.",
       "         On output the columns 1 to K contain",
       "         the updated eigenvectors."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "RHO"=>
      ["[in]",
       "         RHO is DOUBLE PRECISION",
       "         The value of the parameter in the rank one update equation.",
       "         RHO >= 0 required."],
     "DLAMDA"=>
      ["[in,out]",
       "         DLAMDA is DOUBLE PRECISION array, dimension (K)",
       "         The first K elements of this array contain the old roots",
       "         of the deflated updating problem.  These are the poles",
       "         of the secular equation. May be changed on output by",
       "         having lowest order bit set to zero on Cray X-MP, Cray Y-MP,",
       "         Cray-2, or Cray C-90, as described above."],
     "Q2"=>
      ["[in]",
       "         Q2 is DOUBLE PRECISION array, dimension (LDQ2, N)",
       "         The first K columns of this matrix contain the non-deflated",
       "         eigenvectors for the split problem."],
     "INDX"=>
      ["[in]",
       "         INDX is INTEGER array, dimension (N)",
       "         The permutation used to arrange the columns of the deflated",
       "         Q matrix into three groups (see DLAED2).",
       "         The rows of the eigenvectors found by DLAED4 must be likewise",
       "         permuted before the matrix multiply can take place."],
     "CTOT"=>
      ["[in]",
       "         CTOT is INTEGER array, dimension (4)",
       "         A count of the total number of the various types of columns",
       "         in Q, as described in INDX.  The fourth column type is any",
       "         column which has been deflated."],
     "W"=>
      ["[in,out]",
       "         W is DOUBLE PRECISION array, dimension (K)",
       "         The first K elements of this array contain the components",
       "         of the deflation-adjusted updating vector. Destroyed on",
       "         output."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N1 + 1)*K",
       "         Will contain the eigenvectors of the repaired matrix which",
       "         will be multiplied by the previously accumulated eigenvectors",
       "         to update the system."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, an eigenvalue did not converge"]}},
 "dspevd"=>
  {"summary"=>
    ["DSPEVD computes all the eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A in packed storage. If eigenvectors are",
     "desired, it uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array,",
       "                                        dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the required LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be at least 2*N.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least",
       "                                                1 + 6*N + N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the required sizes of the WORK and IWORK",
       "         arrays, returns these values as the first entries of the WORK",
       "         and IWORK arrays, and no error message related to LWORK or",
       "         LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the required LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If JOBZ  = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ  = 'V' and N > 1, LIWORK must be at least 3 + 5*N.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the required sizes of the WORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK and IWORK arrays, and no error message related to",
       "         LWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "zgeqrt2"=>
  {"summary"=>
    ["ZGEQRT2 computes a QR factorization of a complex M-by-N matrix A,",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= N."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the complex M-by-N matrix A.  On exit, the elements on and",
       "         above the diagonal contain the N-by-N upper triangular matrix R; the",
       "         elements below the diagonal are the columns of V.  See below for",
       "         further details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,N)",
       "         The N-by-N upper triangular factor of the block reflector.",
       "         The elements on and above the diagonal contain the block",
       "         reflector T; the elements below the diagonal are not used.",
       "         See below for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zunbdb"=>
  {"summary"=>
    ["ZUNBDB simultaneously bidiagonalizes the blocks of an M-by-M",
     "partitioned unitary matrix X:",
     "                                [ B11 | B12 0  0 ]",
     "    [ X11 | X12 ]   [ P1 |    ] [  0  |  0 -I  0 ] [ Q1 |    ]**H",
     "X = [-----------] = [---------] [----------------] [---------]   .",
     "    [ X21 | X22 ]   [    | P2 ] [ B21 | B22 0  0 ] [    | Q2 ]",
     "                                [  0  |  0  0  I ]",
     "X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is",
     "not the case, then X must be transposed and/or permuted. This can be",
     "done in constant time using the TRANS and SIGNS options. See ZUNCSD",
     "for details.)",
     "The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by-",
     "(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are",
     "represented implicitly by Householder vectors.",
     "B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented",
     "implicitly by angles THETA, PHI."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "SIGNS"=>
      ["[in]",
       "         SIGNS is CHARACTER",
       "         = 'O':      The lower-left block is made nonpositive (the",
       "                     \"other\" convention);",
       "         otherwise:  The upper-right block is made nonpositive (the",
       "                     \"default\" convention)."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11 and X12. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <=",
       "         MIN(P,M-P,M-Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is COMPLEX*16 array, dimension (LDX11,Q)",
       "         On entry, the top-left block of the unitary matrix to be",
       "         reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the columns of tril(X11) specify reflectors for P1,",
       "            the rows of triu(X11,1) specify reflectors for Q1;",
       "         else TRANS = 'T', and",
       "            the rows of triu(X11) specify reflectors for P1,",
       "            the columns of tril(X11,-1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. If TRANS = 'N', then LDX11 >=",
       "         P; else LDX11 >= Q."],
     "X12"=>
      ["[in,out]",
       "         X12 is COMPLEX*16 array, dimension (LDX12,M-Q)",
       "         On entry, the top-right block of the unitary matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the rows of triu(X12) specify the first P reflectors for",
       "            Q2;",
       "         else TRANS = 'T', and",
       "            the columns of tril(X12) specify the first P reflectors",
       "            for Q2."],
     "LDX12"=>
      ["[in]",
       "         LDX12 is INTEGER",
       "         The leading dimension of X12. If TRANS = 'N', then LDX12 >=",
       "         P; else LDX11 >= M-Q."],
     "X21"=>
      ["[in,out]",
       "         X21 is COMPLEX*16 array, dimension (LDX21,Q)",
       "         On entry, the bottom-left block of the unitary matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the columns of tril(X21) specify reflectors for P2;",
       "         else TRANS = 'T', and",
       "            the rows of triu(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "         The leading dimension of X21. If TRANS = 'N', then LDX21 >=",
       "         M-P; else LDX21 >= Q."],
     "X22"=>
      ["[in,out]",
       "         X22 is COMPLEX*16 array, dimension (LDX22,M-Q)",
       "         On entry, the bottom-right block of the unitary matrix to",
       "         be reduced. On exit, the form depends on TRANS:",
       "         If TRANS = 'N', then",
       "            the rows of triu(X22(Q+1:M-P,P+1:M-Q)) specify the last",
       "            M-P-Q reflectors for Q2,",
       "         else TRANS = 'T', and",
       "            the columns of tril(X22(P+1:M-Q,Q+1:M-P)) specify the last",
       "            M-P-Q reflectors for P2."],
     "LDX22"=>
      ["[in]",
       "         LDX22 is INTEGER",
       "         The leading dimension of X22. If TRANS = 'N', then LDX22 >=",
       "         M-P; else LDX22 >= M-Q."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "         The entries of the bidiagonal blocks B11, B12, B21, B22 can",
       "         be computed from the angles THETA and PHI. See Further",
       "         Details."],
     "PHI"=>
      ["[out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "         The entries of the bidiagonal blocks B11, B12, B21, B22 can",
       "         be computed from the angles THETA and PHI. See Further",
       "         Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is COMPLEX*16 array, dimension (P)",
       "         The scalar factors of the elementary reflectors that define",
       "         P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is COMPLEX*16 array, dimension (M-P)",
       "         The scalar factors of the elementary reflectors that define",
       "         P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is COMPLEX*16 array, dimension (Q)",
       "         The scalar factors of the elementary reflectors that define",
       "         Q1."],
     "TAUQ2"=>
      ["[out]",
       "         TAUQ2 is COMPLEX*16 array, dimension (M-Q)",
       "         The scalar factors of the elementary reflectors that define",
       "         Q2."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= M-Q.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slaqr3"=>
  {"summary"=>
    ["   Aggressive early deflation:",
     "   SLAQR3 accepts as input an upper Hessenberg matrix",
     "   H and performs an orthogonal similarity transformation",
     "   designed to detect and deflate fully converged eigenvalues from",
     "   a trailing principal submatrix.  On output H has been over-",
     "   written by a new Hessenberg matrix that is a perturbation of",
     "   an orthogonal similarity transformation of H.  It is to be",
     "   hoped that the final version of H has many zero subdiagonal",
     "   entries."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         If .TRUE., then the Hessenberg matrix H is fully updated",
       "         so that the quasi-triangular Schur factor may be",
       "         computed (in cooperation with the calling subroutine).",
       "         If .FALSE., then only enough of H is updated to preserve",
       "         the eigenvalues."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         If .TRUE., then the orthogonal matrix Z is updated so",
       "         so that the orthogonal Schur factor may be computed",
       "         (in cooperation with the calling subroutine).",
       "         If .FALSE., then Z is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H and (if WANTZ is .TRUE.) the",
       "         order of the orthogonal matrix Z."],
     "KTOP"=>
      ["[in]",
       "         KTOP is INTEGER",
       "         It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.",
       "         KBOT and KTOP together determine an isolated block",
       "         along the diagonal of the Hessenberg matrix."],
     "KBOT"=>
      ["[in]",
       "         KBOT is INTEGER",
       "         It is assumed without a check that either",
       "         KBOT = N or H(KBOT+1,KBOT)=0.  KBOT and KTOP together",
       "         determine an isolated block along the diagonal of the",
       "         Hessenberg matrix."],
     "NW"=>
      ["[in]",
       "         NW is INTEGER",
       "         Deflation window size.  1 .LE. NW .LE. (KBOT-KTOP+1)."],
     "H"=>
      ["[in,out]",
       "         H is REAL array, dimension (LDH,N)",
       "         On input the initial N-by-N section of H stores the",
       "         Hessenberg matrix undergoing aggressive early deflation.",
       "         On output H has been transformed by an orthogonal",
       "         similarity transformation, perturbed, and the returned",
       "         to Hessenberg form that (it is to be hoped) has some",
       "         zero subdiagonal entries."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "         Leading dimension of H just as declared in the calling",
       "         subroutine.  N .LE. LDH"],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ,N)",
       "         IF WANTZ is .TRUE., then on output, the orthogonal",
       "         similarity transformation mentioned above has been",
       "         accumulated into Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "         If WANTZ is .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer",
       "         The leading dimension of Z just as declared in the",
       "         calling subroutine.  1 .LE. LDZ."],
     "NS"=>
      ["[out]",
       "         NS is integer",
       "         The number of unconverged (ie approximate) eigenvalues",
       "         returned in SR and SI that may be used as shifts by the",
       "         calling subroutine."],
     "ND"=>
      ["[out]",
       "         ND is integer",
       "         The number of converged eigenvalues uncovered by this",
       "         subroutine."],
     "SR"=>["[out]", "         SR is REAL array, dimension KBOT"],
     "SI"=>
      ["[out]",
       "         SI is REAL array, dimension KBOT",
       "         On output, the real and imaginary parts of approximate",
       "         eigenvalues that may be used for shifts are stored in",
       "         SR(KBOT-ND-NS+1) through SR(KBOT-ND) and",
       "         SI(KBOT-ND-NS+1) through SI(KBOT-ND), respectively.",
       "         The real and imaginary parts of converged eigenvalues",
       "         are stored in SR(KBOT-ND+1) through SR(KBOT) and",
       "         SI(KBOT-ND+1) through SI(KBOT), respectively."],
     "V"=>
      ["[out]",
       "         V is REAL array, dimension (LDV,NW)",
       "         An NW-by-NW work array."],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "         The leading dimension of V just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "         The number of columns of T.  NH.GE.NW."],
     "T"=>["[out]", "         T is REAL array, dimension (LDT,NW)"],
     "LDT"=>
      ["[in]",
       "         LDT is integer",
       "         The leading dimension of T just as declared in the",
       "         calling subroutine.  NW .LE. LDT"],
     "NV"=>
      ["[in]",
       "         NV is integer",
       "         The number of rows of work array WV available for",
       "         workspace.  NV.GE.NW."],
     "WV"=>["[out]", "         WV is REAL array, dimension (LDWV,NW)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer",
       "         The leading dimension of W just as declared in the",
       "         calling subroutine.  NW .LE. LDV"],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension LWORK.",
       "         On exit, WORK(1) is set to an estimate of the optimal value",
       "         of LWORK for the given values of N, NW, KTOP and KBOT."],
     "LWORK"=>
      ["[in]",
       "         LWORK is integer",
       "         The dimension of the work array WORK.  LWORK = 2*NW",
       "         suffices, but greater efficiency may result from larger",
       "         values of LWORK.",
       "         If LWORK = -1, then a workspace query is assumed; SLAQR3",
       "         only estimates the optimal workspace size for the given",
       "         values of N, NW, KTOP and KBOT.  The estimate is returned",
       "         in WORK(1).  No error message related to LWORK is issued",
       "         by XERBLA.  Neither H nor Z are accessed."]}},
 "chpsvx"=>
  {"summary"=>
    ["CHPSVX uses the diagonal pivoting factorization A = U*D*U**H or",
     "A = L*D*L**H to compute the solution to a complex system of linear",
     "equations A * X = B, where A is an N-by-N Hermitian matrix stored",
     "in packed format and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "sdisna"=>
  {"summary"=>
    ["SDISNA 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 m-by-n matrix. The reciprocal",
     "condition number is the 'gap' between the corresponding eigenvalue or",
     "singular value and the nearest other one.",
     "The bound on the error, measured by angle in radians, in the I-th",
     "computed vector is given by",
     "       SLAMCH( 'E' ) * ( ANORM / SEP( I ) )",
     "where ANORM = 2-norm(A) = max( abs( D(j) ) ).  SEP(I) is not allowed",
     "to be smaller than SLAMCH( 'E' )*ANORM in order to limit the size of",
     "the error bound.",
     "SDISNA may also be used to compute error bounds for eigenvectors of",
     "the generalized symmetric definite eigenproblem."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies for which problem the reciprocal condition numbers",
       "         should be computed:",
       "         = 'E':  the eigenvectors of a symmetric/Hermitian matrix;",
       "         = 'L':  the left singular vectors of a general matrix;",
       "         = 'R':  the right singular vectors of a general matrix."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         If JOB = 'L' or 'R', the number of columns of the matrix,",
       "         in which case N >= 0. Ignored if JOB = 'E'."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (M) if JOB = 'E'",
       "                             dimension (min(M,N)) if JOB = 'L' or 'R'",
       "         The eigenvalues (if JOB = 'E') or singular values (if JOB =",
       "         'L' or 'R') of the matrix, in either increasing or decreasing",
       "         order. If singular values, they must be non-negative."],
     "SEP"=>
      ["[out]",
       "         SEP is REAL array, dimension (M) if JOB = 'E'",
       "                              dimension (min(M,N)) if JOB = 'L' or 'R'",
       "         The reciprocal condition numbers of the vectors."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "sbdsdc"=>
  {"summary"=>
    ["SBDSDC computes the singular value decomposition (SVD) of a real",
     "N-by-N (upper or lower) bidiagonal matrix B:  B = U * S * VT,",
     "using a divide and conquer method, where S is a diagonal matrix",
     "with non-negative diagonal elements (the singular values of B), and",
     "U and VT are orthogonal matrices of left and right singular vectors,",
     "respectively. SBDSDC can be used to compute all singular values,",
     "and optionally, singular vectors or singular vectors in compact form.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none.  See SLASD3 for details.",
     "The code currently calls SLASDQ if singular values only are desired.",
     "However, it can be slightly modified to compute singular values",
     "using the divide and conquer method."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  B is upper bidiagonal.",
       "         = 'L':  B is lower bidiagonal."],
     "COMPQ"=>
      ["[in]",
       "         COMPQ is CHARACTER*1",
       "         Specifies whether singular vectors are to be computed",
       "         as follows:",
       "         = 'N':  Compute singular values only;",
       "         = 'P':  Compute singular values and compute singular",
       "                 vectors in compact form;",
       "         = 'I':  Compute singular values and singular vectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix B.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the bidiagonal matrix B.",
       "         On exit, if INFO=0, the singular values of B."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the elements of E contain the offdiagonal",
       "         elements of the bidiagonal matrix whose SVD is desired.",
       "         On exit, E has been destroyed."],
     "U"=>
      ["[out]",
       "         U is REAL array, dimension (LDU,N)",
       "         If  COMPQ = 'I', then:",
       "            On exit, if INFO = 0, U contains the left singular vectors",
       "            of the bidiagonal matrix.",
       "         For other values of COMPQ, U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1.",
       "         If singular vectors are desired, then LDU >= max( 1, N )."],
     "VT"=>
      ["[out]",
       "         VT is REAL array, dimension (LDVT,N)",
       "         If  COMPQ = 'I', then:",
       "            On exit, if INFO = 0, VT**T contains the right singular",
       "            vectors of the bidiagonal matrix.",
       "         For other values of COMPQ, VT is not referenced."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1.",
       "         If singular vectors are desired, then LDVT >= max( 1, N )."],
     "Q"=>
      ["[out]",
       "         Q is REAL array, dimension (LDQ)",
       "         If  COMPQ = 'P', then:",
       "            On exit, if INFO = 0, Q and IQ contain the left",
       "            and right singular vectors in a compact form,",
       "            requiring O(N log N) space instead of 2*N**2.",
       "            In particular, Q contains all the REAL data in",
       "            LDQ >= N*(11 + 2*SMLSIZ + 8*INT(LOG_2(N/(SMLSIZ+1))))",
       "            words of memory, where SMLSIZ is returned by ILAENV and",
       "            is equal to the maximum size of the subproblems at the",
       "            bottom of the computation tree (usually about 25).",
       "         For other values of COMPQ, Q is not referenced."],
     "IQ"=>
      ["[out]",
       "         IQ is INTEGER array, dimension (LDIQ)",
       "         If  COMPQ = 'P', then:",
       "            On exit, if INFO = 0, Q and IQ contain the left",
       "            and right singular vectors in a compact form,",
       "            requiring O(N log N) space instead of 2*N**2.",
       "            In particular, IQ contains all INTEGER data in",
       "            LDIQ >= N*(3 + 3*INT(LOG_2(N/(SMLSIZ+1))))",
       "            words of memory, where SMLSIZ is returned by ILAENV and",
       "            is equal to the maximum size of the subproblems at the",
       "            bottom of the computation tree (usually about 25).",
       "         For other values of COMPQ, IQ is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         If COMPQ = 'N' then LWORK >= (4 * N).",
       "         If COMPQ = 'P' then LWORK >= (6 * N).",
       "         If COMPQ = 'I' then LWORK >= (3 * N**2 + 4 * N)."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (8*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The algorithm failed to compute a singular value.",
       "               The update process of divide and conquer failed."]}},
 "dtfttp"=>
  {"summary"=>
    ["DTFTTP copies a triangular matrix A from rectangular full packed",
     "format (TF) to standard packed format (TP)."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  ARF is in Normal format;",
       "         = 'T':  ARF is in Transpose format;"],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "ARF"=>
      ["[in]",
       "         ARF is DOUBLE PRECISION array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A stored in",
       "         RFP format. For a further discussion see Notes below."],
     "AP"=>
      ["[out]",
       "         AP is DOUBLE PRECISION array, dimension ( N*(N+1)/2 ),",
       "         On exit, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "shsein"=>
  {"summary"=>
    ["SHSEIN uses inverse iteration to find specified right and/or left",
     "eigenvectors of a real upper Hessenberg matrix H.",
     "The right eigenvector x and the left eigenvector y of the matrix H",
     "corresponding to an eigenvalue w are defined by:",
     "             H * x = w * x,     y**h * H = w * y**h",
     "where y**h denotes the conjugate transpose of the vector y."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R': compute right eigenvectors only;",
       "         = 'L': compute left eigenvectors only;",
       "         = 'B': compute both right and left eigenvectors."],
     "EIGSRC"=>
      ["[in]",
       "         EIGSRC is CHARACTER*1",
       "         Specifies the source of eigenvalues supplied in (WR,WI):",
       "         = 'Q': the eigenvalues were found using SHSEQR; thus, if",
       "                H has zero subdiagonal elements, and so is",
       "                block-triangular, then the j-th eigenvalue can be",
       "                assumed to be an eigenvalue of the block containing",
       "                the j-th row/column.  This property allows SHSEIN to",
       "                perform inverse iteration on just one diagonal block.",
       "         = 'N': no assumptions are made on the correspondence",
       "                between eigenvalues and diagonal blocks.  In this",
       "                case, SHSEIN must always perform inverse iteration",
       "                using the whole matrix H."],
     "INITV"=>
      ["[in]",
       "         INITV is CHARACTER*1",
       "         = 'N': no initial vectors are supplied;",
       "         = 'U': user-supplied initial vectors are stored in the arrays",
       "                VL and/or VR."],
     "SELECT"=>
      ["[in,out]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         Specifies the eigenvectors to be computed. To select the",
       "         real eigenvector corresponding to a real eigenvalue WR(j),",
       "         SELECT(j) must be set to .TRUE.. To select the complex",
       "         eigenvector corresponding to a complex eigenvalue",
       "         (WR(j),WI(j)), with complex conjugate (WR(j+1),WI(j+1)),",
       "         either SELECT(j) or SELECT(j+1) or both must be set to",
       "         .TRUE.; then on exit SELECT(j) is .TRUE. and SELECT(j+1) is",
       "         .FALSE.."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "H"=>
      ["[in]",
       "         H is REAL array, dimension (LDH,N)",
       "         The upper Hessenberg matrix H.",
       "         If a NaN is detected in H, the routine will return with INFO=-6."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max(1,N)."],
     "WR"=>["[in,out]", "         WR is REAL array, dimension (N)"],
     "WI"=>
      ["[in]",
       "         WI is REAL array, dimension (N)",
       "         On entry, the real and imaginary parts of the eigenvalues of",
       "         H; a complex conjugate pair of eigenvalues must be stored in",
       "         consecutive elements of WR and WI.",
       "         On exit, WR may have been altered since close eigenvalues",
       "         are perturbed slightly in searching for independent",
       "         eigenvectors."],
     "VL"=>
      ["[in,out]",
       "         VL is REAL array, dimension (LDVL,MM)",
       "         On entry, if INITV = 'U' and SIDE = 'L' or 'B', VL must",
       "         contain starting vectors for the inverse iteration for the",
       "         left eigenvectors; the starting vector for each eigenvector",
       "         must be in the same column(s) in which the eigenvector will",
       "         be stored.",
       "         On exit, if SIDE = 'L' or 'B', the left eigenvectors",
       "         specified by SELECT will be stored consecutively in the",
       "         columns of VL, in the same order as their eigenvalues. A",
       "         complex eigenvector corresponding to a complex eigenvalue is",
       "         stored in two consecutive columns, the first holding the real",
       "         part and the second the imaginary part.",
       "         If SIDE = 'R', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= max(1,N) if SIDE = 'L' or 'B'; LDVL >= 1 otherwise."],
     "VR"=>
      ["[in,out]",
       "         VR is REAL array, dimension (LDVR,MM)",
       "         On entry, if INITV = 'U' and SIDE = 'R' or 'B', VR must",
       "         contain starting vectors for the inverse iteration for the",
       "         right eigenvectors; the starting vector for each eigenvector",
       "         must be in the same column(s) in which the eigenvector will",
       "         be stored.",
       "         On exit, if SIDE = 'R' or 'B', the right eigenvectors",
       "         specified by SELECT will be stored consecutively in the",
       "         columns of VR, in the same order as their eigenvalues. A",
       "         complex eigenvector corresponding to a complex eigenvalue is",
       "         stored in two consecutive columns, the first holding the real",
       "         part and the second the imaginary part.",
       "         If SIDE = 'L', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= max(1,N) if SIDE = 'R' or 'B'; LDVR >= 1 otherwise."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR required to",
       "         store the eigenvectors; each selected real eigenvector",
       "         occupies one column and each selected complex eigenvector",
       "         occupies two columns."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension ((N+2)*N)"],
     "IFAILL"=>
      ["[out]",
       "         IFAILL is INTEGER array, dimension (MM)",
       "         If SIDE = 'L' or 'B', IFAILL(i) = j > 0 if the left",
       "         eigenvector in the i-th column of VL (corresponding to the",
       "         eigenvalue w(j)) failed to converge; IFAILL(i) = 0 if the",
       "         eigenvector converged satisfactorily. If the i-th and (i+1)th",
       "         columns of VL hold a complex eigenvector, then IFAILL(i) and",
       "         IFAILL(i+1) are set to the same value.",
       "         If SIDE = 'R', IFAILL is not referenced."],
     "IFAILR"=>
      ["[out]",
       "         IFAILR is INTEGER array, dimension (MM)",
       "         If SIDE = 'R' or 'B', IFAILR(i) = j > 0 if the right",
       "         eigenvector in the i-th column of VR (corresponding to the",
       "         eigenvalue w(j)) failed to converge; IFAILR(i) = 0 if the",
       "         eigenvector converged satisfactorily. If the i-th and (i+1)th",
       "         columns of VR hold a complex eigenvector, then IFAILR(i) and",
       "         IFAILR(i+1) are set to the same value.",
       "         If SIDE = 'L', IFAILR is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, i is the number of eigenvectors which",
       "               failed to converge; see IFAILL and IFAILR for further",
       "               details."]}},
 "slarfb"=>
  {"summary"=>
    ["SLARFB applies a real block reflector H or its transpose H**T to a",
     "real m by n matrix C, from either the left or the right."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H**T from the Left",
       "         = 'R': apply H or H**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'T': apply H**T (Transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columnwise",
       "         = 'R': Rowwise"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T (= the number of elementary",
       "         reflectors whose product defines the block reflector)."],
     "V"=>
      ["[in]",
       "         V is REAL array, dimension",
       "                               (LDV,K) if STOREV = 'C'",
       "                               (LDV,M) if STOREV = 'R' and SIDE = 'L'",
       "                               (LDV,N) if STOREV = 'R' and SIDE = 'R'",
       "         The matrix V. See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);",
       "         if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);",
       "         if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is REAL array, dimension (LDT,K)",
       "         The triangular k by k matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (LDWORK,K)"],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= max(1,N);",
       "         if SIDE = 'R', LDWORK >= max(1,M)."]}},
 "cla_gbrcond_c"=>
  {"summary"=>
    ["   CLA_GBRCOND_C Computes the infinity norm condition number of",
     "   op(A) * inv(diag(C)) where C is a REAL vector."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "    On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by CGBTRF.  U is stored as an upper triangular",
       "    band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1,",
       "    and the multipliers used during the factorization are stored",
       "    in rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by CGBTRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The vector C in the formula op(A) * inv(diag(C))."],
     "CAPPLY"=>
      ["[in]",
       "         CAPPLY is LOGICAL",
       "    If .TRUE. then access the vector C in the formula above."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is REAL array, dimension (N).",
       "    Workspace."]}},
 "clanhe"=>
  {"summary"=>
    ["CLANHE  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex hermitian matrix A.",
     "   CLANHE = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in CLANHE as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         hermitian matrix A is to be referenced.",
       "         = 'U':  Upper triangular part of A is referenced",
       "         = 'L':  Lower triangular part of A is referenced"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, CLANHE is",
       "         set to zero."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The hermitian matrix A.  If UPLO = 'U', the leading n by n",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading n by n lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced. Note that the imaginary parts of the diagonal",
       "         elements need not be set and are assumed to be zero."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(N,1)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "zgeql2"=>
  {"summary"=>
    ["ZGEQL2 computes a QL factorization of a complex m by n matrix A:",
     "A = Q * L."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, if m >= n, the lower triangle of the subarray",
       "         A(m-n+1:m,1:n) contains the n by n lower triangular matrix L;",
       "         if m <= n, the elements on and below the (n-m)-th",
       "         superdiagonal contain the m by n lower trapezoidal matrix L;",
       "         the remaining elements, with the array TAU, represent the",
       "         unitary matrix Q as a product of elementary reflectors",
       "         (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zunml2"=>
  {"summary"=>
    ["ZUNML2 overwrites the general complex m-by-n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**H* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**H if SIDE = 'R' and TRANS = 'C',",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(k)**H . . . H(2)**H H(1)**H",
     "as returned by ZGELQF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left",
       "         = 'R': apply Q or Q**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         ZGELQF in the first k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGELQF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "slasq5"=>
  {"summary"=>
    ["SLASQ5 computes one dqds transform in ping-pong form, one",
     "version for IEEE machines another for non IEEE machines."],
   "param"=>
    {"I0"=>["[in]", "         I0 is INTEGER", "       First index."],
     "N0"=>["[in]", "         N0 is INTEGER", "       Last index."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension ( 4*N )",
       "       Z holds the qd array. EMIN is stored in Z(4*N0) to avoid",
       "       an extra argument."],
     "PP"=>
      ["[in]",
       "         PP is INTEGER",
       "       PP=0 for ping, PP=1 for pong."],
     "TAU"=>["[in]", "         TAU is REAL", "       This is the shift."],
     "SIGMA"=>
      ["[in]",
       "         SIGMA is REAL",
       "       This is the accumulated shift up to this step."],
     "DMIN"=>["[out]", "         DMIN is REAL", "       Minimum value of d."],
     "DMIN1"=>
      ["[out]",
       "         DMIN1 is REAL",
       "       Minimum value of d, excluding D( N0 )."],
     "DMIN2"=>
      ["[out]",
       "         DMIN2 is REAL",
       "       Minimum value of d, excluding D( N0 ) and D( N0-1 )."],
     "DN"=>
      ["[out]", "         DN is REAL", "       d(N0), the last value of d."],
     "DNM1"=>["[out]", "         DNM1 is REAL", "       d(N0-1)."],
     "DNM2"=>["[out]", "         DNM2 is REAL", "       d(N0-2)."],
     "IEEE"=>
      ["[in]",
       "         IEEE is LOGICAL",
       "       Flag for IEEE or non IEEE arithmetic."],
     "EPS"=>
      ["[in]",
       "        EPS is REAL",
       "       This is the value of epsilon used."]}},
 "shseqr"=>
  {"summary"=>
    ["   SHSEQR computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**T, where T is an upper quasi-triangular matrix (the",
     "   Schur form), and Z is the orthogonal matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input orthogonal",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the orthogonal matrix Q:  A = Q*H*Q**T = (QZ)*T*(QZ)**T."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "          = 'E':  compute eigenvalues only;",
       "          = 'S':  compute eigenvalues and the Schur form T."],
     "COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "          = 'N':  no Schur vectors are computed;",
       "          = 'I':  Z is initialized to the unit matrix and the matrix Z",
       "                  of Schur vectors of H is returned;",
       "          = 'V':  Z must contain an orthogonal matrix Q on entry, and",
       "                  the product Q*Z is returned."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally",
       "          set by a previous call to SGEBAL, and then passed to ZGEHRD",
       "          when the matrix output by SGEBAL is reduced to Hessenberg",
       "          form. Otherwise ILO and IHI should be set to 1 and N",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is REAL array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and JOB = 'S', then H contains the",
       "          upper quasi-triangular matrix T from the Schur decomposition",
       "          (the Schur form); 2-by-2 diagonal blocks (corresponding to",
       "          complex conjugate pairs of eigenvalues) are returned in",
       "          standard form, with H(i,i) = H(i+1,i+1) and",
       "          H(i+1,i)*H(i,i+1).LT.0. If INFO = 0 and JOB = 'E', the",
       "          contents of H are unspecified on exit.  (The output value of",
       "          H when INFO.GT.0 is given under the description of INFO",
       "          below.)",
       "          Unlike earlier versions of SHSEQR, this subroutine may",
       "          explicitly H(i,j) = 0 for i.GT.j and j = 1, 2, ... ILO-1",
       "          or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "WR"=>["[out]", "         WR is REAL array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is REAL array, dimension (N)",
       "          The real and imaginary parts, respectively, of the computed",
       "          eigenvalues. If two eigenvalues are computed as a complex",
       "          conjugate pair, they are stored in consecutive elements of",
       "          WR and WI, say the i-th and (i+1)th, with WI(i) .GT. 0 and",
       "          WI(i+1) .LT. 0. If JOB = 'S', the eigenvalues are stored in",
       "          the same order as on the diagonal of the Schur form returned",
       "          in H, with WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2",
       "          diagonal block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and",
       "          WI(i+1) = -WI(i)."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ,N)",
       "          If COMPZ = 'N', Z is not referenced.",
       "          If COMPZ = 'I', on entry Z need not be set and on exit,",
       "          if INFO = 0, Z contains the orthogonal matrix Z of the Schur",
       "          vectors of H.  If COMPZ = 'V', on entry Z must contain an",
       "          N-by-N matrix Q, which is assumed to be equal to the unit",
       "          matrix except for the submatrix Z(ILO:IHI,ILO:IHI). On exit,",
       "          if INFO = 0, Z contains Q*Z.",
       "          Normally Q is the orthogonal matrix generated by SORGHR",
       "          after the call to SGEHRD which formed the Hessenberg matrix",
       "          H. (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if COMPZ = 'I' or",
       "          COMPZ = 'V', then LDZ.GE.MAX(1,N).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (LWORK)",
       "          On exit, if INFO = 0, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient and delivers very good and sometimes",
       "          optimal performance.  However, LWORK as large as 11*N",
       "          may be required for optimal performance.  A workspace",
       "          query is recommended to determine the optimal workspace",
       "          size.",
       "          If LWORK = -1, then SHSEQR does a workspace query.",
       "          In this case, SHSEQR checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .LT. 0:  if INFO = -i, the i-th argument had an illegal",
       "                   value",
       "          .GT. 0:  if INFO = i, SHSEQR failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and JOB = 'E', then on exit, the",
       "               remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and JOB   = 'S', then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is an orthogonal matrix.  The final",
       "               value of H is upper Hessenberg and quasi-triangular",
       "               in rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and COMPZ = 'V', then on exit",
       "                 (final value of Z)  =  (initial value of Z)*U",
       "               where U is the orthogonal matrix in (*) (regard-",
       "               less of the value of JOB.)",
       "               If INFO .GT. 0 and COMPZ = 'I', then on exit",
       "                     (final value of Z)  = U",
       "               where U is the orthogonal matrix in (*) (regard-",
       "               less of the value of JOB.)",
       "               If INFO .GT. 0 and COMPZ = 'N', then Z is not",
       "               accessed."]}},
 "dtbrfs"=>
  {"summary"=>
    ["DTBRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular band",
     "coefficient matrix.",
     "The solution matrix X must be computed by DTBTRS or some other",
     "means before entering this routine.  DTBRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dormqr"=>
  {"summary"=>
    ["DORMQR overwrites the general real M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'T':      Q**T * C       C * Q**T",
     "where Q is a real orthogonal matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by DGEQRF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**T from the Left;",
       "         = 'R': apply Q or Q**T from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'T':  Transpose, apply Q**T."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         DGEQRF in the first k columns of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGEQRF."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clarrv"=>
  {"summary"=>
    ["CLARRV computes the eigenvectors of the tridiagonal matrix",
     "T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T.",
     "The input eigenvalues should have been computed by SLARRE."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         Lower bound of the interval that contains the desired",
       "         eigenvalues. VL < VU. Needed to compute gaps on the left or right",
       "         end of the extremal eigenvalues in the desired RANGE."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         Upper bound of the interval that contains the desired",
       "         eigenvalues. VL < VU. Needed to compute gaps on the left or right",
       "         end of the extremal eigenvalues in the desired RANGE."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the N diagonal elements of the diagonal matrix D.",
       "         On exit, D may be overwritten."],
     "L"=>
      ["[in,out]",
       "         L is REAL array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the unit",
       "         bidiagonal matrix L are in elements 1 to N-1 of L",
       "         (if the matrix is not split.) At the end of each block",
       "         is stored the corresponding shift as given by SLARRE.",
       "         On exit, L is overwritten."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "         The minimum pivot allowed in the Sturm sequence."],
     "ISPLIT"=>
      ["[in]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into blocks.",
       "         The first block consists of rows/columns 1 to",
       "         ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1",
       "         through ISPLIT( 2 ), etc."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The total number of input eigenvalues.  0 <= M <= N."],
     "DOL"=>["[in]", "         DOL is INTEGER"],
     "DOU"=>
      ["[in]",
       "         DOU is INTEGER",
       "         If the user wants to compute only selected eigenvectors from all",
       "         the eigenvalues supplied, he can specify an index range DOL:DOU.",
       "         Or else the setting DOL=1, DOU=M should be applied.",
       "         Note that DOL and DOU refer to the order in which the eigenvalues",
       "         are stored in W.",
       "         If the user wants to compute only selected eigenpairs, then",
       "         the columns DOL-1 to DOU+1 of the eigenvector space Z contain the",
       "         computed eigenvectors. All other columns of Z are set to zero."],
     "MINRGP"=>["[in]", "         MINRGP is REAL"],
     "RTOL1"=>["[in]", "         RTOL1 is REAL"],
     "RTOL2"=>
      ["[in]",
       "         RTOL2 is REAL",
       "          Parameters for bisection.",
       "          An interval [LEFT,RIGHT] has converged if",
       "          RIGHT-LEFT.LT.MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )"],
     "W"=>
      ["[in,out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements of W contain the APPROXIMATE eigenvalues for",
       "         which eigenvectors are to be computed.  The eigenvalues",
       "         should be grouped by split-off block and ordered from",
       "         smallest to largest within the block ( The output array",
       "         W from SLARRE is expected here ). Furthermore, they are with",
       "         respect to the shift of the corresponding root representation",
       "         for their block. On exit, W holds the eigenvalues of the",
       "         UNshifted matrix."],
     "WERR"=>
      ["[in,out]",
       "         WERR is REAL array, dimension (N)",
       "         The first M elements contain the semiwidth of the uncertainty",
       "         interval of the corresponding eigenvalue in W"],
     "WGAP"=>
      ["[in,out]",
       "         WGAP is REAL array, dimension (N)",
       "         The separation from the right neighbor eigenvalue in W."],
     "IBLOCK"=>
      ["[in]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         The indices of the blocks (submatrices) associated with the",
       "         corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue",
       "         W(i) belongs to the first block from the top, =2 if W(i)",
       "         belongs to the second block, etc."],
     "INDEXW"=>
      ["[in]",
       "         INDEXW is INTEGER array, dimension (N)",
       "         The indices of the eigenvalues within each block (submatrix);",
       "         for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the",
       "         i-th eigenvalue W(i) is the 10-th eigenvalue in the second block."],
     "GERS"=>
      ["[in]",
       "         GERS is REAL array, dimension (2*N)",
       "         The N Gerschgorin intervals (the i-th Gerschgorin interval",
       "         is (GERS(2*i-1), GERS(2*i)). The Gerschgorin intervals should",
       "         be computed from the original UNshifted matrix."],
     "Z"=>
      ["[out]",
       "         Z is array, dimension (LDZ, max(1,M) )",
       "         If INFO = 0, the first M columns of Z contain the",
       "         orthonormal eigenvectors of the matrix T",
       "         corresponding to the input eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The I-th eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*I-1 ) through",
       "         ISUPPZ( 2*I )."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (12*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (7*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         > 0:  A problem occurred in CLARRV.",
       "         < 0:  One of the called subroutines signaled an internal problem.",
       "               Needs inspection of the corresponding parameter IINFO",
       "               for further information.",
       "         =-1:  Problem in SLARRB when refining a child's eigenvalues.",
       "         =-2:  Problem in SLARRF when computing the RRR of a child.",
       "               When a child is inside a tight cluster, it can be difficult",
       "               to find an RRR. A partial remedy from the user's point of",
       "               view is to make the parameter MINRGP smaller and recompile.",
       "               However, as the orthogonality of the computed vectors is",
       "               proportional to 1/MINRGP, the user should be aware that",
       "               he might be trading in precision when he decreases MINRGP.",
       "         =-3:  Problem in SLARRB when refining a single eigenvalue",
       "               after the Rayleigh correction was rejected.",
       "         = 5:  The Rayleigh Quotient Iteration failed to converge to",
       "               full accuracy in MAXITR steps."]}},
 "dlatbs"=>
  {"summary"=>
    ["DLATBS solves one of the triangular systems",
     "   A *x = s*b  or  A**T*x = s*b",
     "with scaling to prevent overflow, where A is an upper or lower",
     "triangular band matrix.  Here A**T denotes the transpose of A, x and b",
     "are n-element vectors, and s is a scaling factor, usually less than",
     "or equal to 1, chosen so that the components of x will be less than",
     "the overflow threshold.  If the unscaled problem will not cause",
     "overflow, the Level 2 BLAS routine DTBSV is called.  If the matrix A",
     "is singular (A(j,j) = 0 for some j), then s is set to 0 and a",
     "non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b  (No transpose)",
       "         = 'T':  Solve A**T* x = s*b  (Transpose)",
       "         = 'C':  Solve A**T* x = s*b  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of subdiagonals or superdiagonals in the",
       "         triangular matrix A.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first KD+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is DOUBLE PRECISION",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b  or  A**T* x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is DOUBLE PRECISION array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "cgebd2"=>
  {"summary"=>
    ["CGEBD2 reduces a complex general m by n matrix A to upper or lower",
     "real bidiagonal form B by a unitary transformation: Q**H * A * P = B.",
     "If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the m by n general matrix to be reduced.",
       "         On exit,",
       "         if m >= n, the diagonal and the first superdiagonal are",
       "           overwritten with the upper bidiagonal matrix B; the",
       "           elements below the diagonal, with the array TAUQ, represent",
       "           the unitary matrix Q as a product of elementary",
       "           reflectors, and the elements above the first superdiagonal,",
       "           with the array TAUP, represent the unitary matrix P as",
       "           a product of elementary reflectors;",
       "         if m < n, the diagonal and the first subdiagonal are",
       "           overwritten with the lower bidiagonal matrix B; the",
       "           elements below the first subdiagonal, with the array TAUQ,",
       "           represent the unitary matrix Q as a product of",
       "           elementary reflectors, and the elements above the diagonal,",
       "           with the array TAUP, represent the unitary matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (min(M,N)-1)",
       "         The off-diagonal elements of the bidiagonal matrix B:",
       "         if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;",
       "         if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is COMPLEX array dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the unitary matrix P. See Further Details."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (max(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value."]}},
 "dspcon"=>
  {"summary"=>
    ["DSPCON estimates the reciprocal of the condition number (in the",
     "1-norm) of a real symmetric packed matrix A using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by DSPTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by DSPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSPTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dtrevc"=>
  {"summary"=>
    ["DTREVC computes some or all of the right and/or left eigenvectors of",
     "a real upper quasi-triangular matrix T.",
     "Matrices of this type are produced by the Schur factorization of",
     "a real general matrix:  A = Q*T*Q**T, as computed by DHSEQR.",
     "The right eigenvector x and the left eigenvector y of T corresponding",
     "to an eigenvalue w are defined by:",
     "   T*x = w*x,     (y**H)*T = w*(y**H)",
     "where y**H denotes the conjugate transpose of y.",
     "The eigenvalues are not input to this routine, but are read directly",
     "from the diagonal blocks of T.",
     "This routine returns the matrices X and/or Y of right and left",
     "eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an",
     "input matrix.  If Q is the orthogonal factor that reduces a matrix",
     "A to Schur form T, then Q*X and Q*Y are the matrices of right and",
     "left eigenvectors of A."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  compute right eigenvectors only;",
       "         = 'L':  compute left eigenvectors only;",
       "         = 'B':  compute both right and left eigenvectors."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A':  compute all right and/or left eigenvectors;",
       "         = 'B':  compute all right and/or left eigenvectors,",
       "                 backtransformed by the matrices in VR and/or VL;",
       "         = 'S':  compute selected right and/or left eigenvectors,",
       "                 as indicated by the logical array SELECT."],
     "SELECT"=>
      ["[in,out]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenvectors to be",
       "         computed.",
       "         If w(j) is a real eigenvalue, the corresponding real",
       "         eigenvector is computed if SELECT(j) is .TRUE..",
       "         If w(j) and w(j+1) are the real and imaginary parts of a",
       "         complex eigenvalue, the corresponding complex eigenvector is",
       "         computed if either SELECT(j) or SELECT(j+1) is .TRUE., and",
       "         on exit SELECT(j) is set to .TRUE. and SELECT(j+1) is set to",
       "         .FALSE..",
       "         Not referenced if HOWMNY = 'A' or 'B'."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (LDT,N)",
       "         The upper quasi-triangular matrix T in Schur canonical form."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in,out]",
       "         VL is DOUBLE PRECISION array, dimension (LDVL,MM)",
       "         On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must",
       "         contain an N-by-N matrix Q (usually the orthogonal matrix Q",
       "         of Schur vectors returned by DHSEQR).",
       "         On exit, if SIDE = 'L' or 'B', VL contains:",
       "         if HOWMNY = 'A', the matrix Y of left eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*Y;",
       "         if HOWMNY = 'S', the left eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VL, in the same order as their",
       "                          eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part, and the second the imaginary part.",
       "         Not referenced if SIDE = 'R'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.  LDVL >= 1, and if",
       "         SIDE = 'L' or 'B', LDVL >= N."],
     "VR"=>
      ["[in,out]",
       "         VR is DOUBLE PRECISION array, dimension (LDVR,MM)",
       "         On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must",
       "         contain an N-by-N matrix Q (usually the orthogonal matrix Q",
       "         of Schur vectors returned by DHSEQR).",
       "         On exit, if SIDE = 'R' or 'B', VR contains:",
       "         if HOWMNY = 'A', the matrix X of right eigenvectors of T;",
       "         if HOWMNY = 'B', the matrix Q*X;",
       "         if HOWMNY = 'S', the right eigenvectors of T specified by",
       "                          SELECT, stored consecutively in the columns",
       "                          of VR, in the same order as their",
       "                          eigenvalues.",
       "         A complex eigenvector corresponding to a complex eigenvalue",
       "         is stored in two consecutive columns, the first holding the",
       "         real part and the second the imaginary part.",
       "         Not referenced if SIDE = 'L'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.  LDVR >= 1, and if",
       "         SIDE = 'R' or 'B', LDVR >= N."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of columns in the arrays VL and/or VR. MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of columns in the arrays VL and/or VR actually",
       "         used to store the eigenvectors.",
       "         If HOWMNY = 'A' or 'B', M is set to N.",
       "         Each selected real eigenvector occupies one column and each",
       "         selected complex eigenvector occupies two columns."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clar2v"=>
  {"summary"=>
    ["CLAR2V applies a vector of complex plane rotations with real cosines",
     "from both sides to a sequence of 2-by-2 complex Hermitian matrices,",
     "defined by the elements of the vectors x, y and z. For i = 1,2,...,n",
     "   (       x(i)  z(i) ) :=",
     "   ( conjg(z(i)) y(i) )",
     "     (  c(i) conjg(s(i)) ) (       x(i)  z(i) ) ( c(i) -conjg(s(i)) )",
     "     ( -s(i)       c(i)  ) ( conjg(z(i)) y(i) ) ( s(i)        c(i)  )"],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be applied."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (1+(N-1)*INCX)",
       "         The vector x; the elements of x are assumed to be real."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX array, dimension (1+(N-1)*INCX)",
       "         The vector y; the elements of y are assumed to be real."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (1+(N-1)*INCX)",
       "         The vector z."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X, Y and Z. INCX > 0."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is COMPLEX array, dimension (1+(N-1)*INCC)",
       "         The sines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C and S. INCC > 0."]}},
 "dorg2l"=>
  {"summary"=>
    ["DORG2L generates an m by n real matrix Q with orthonormal columns,",
     "which is defined as the last n columns of a product of k elementary",
     "reflectors of order m",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by DGEQLF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. M >= N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. N >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the (n-k+i)-th column must contain the vector which",
       "         defines the elementary reflector H(i), for i = 1,2,...,k, as",
       "         returned by DGEQLF in the last k columns of its array",
       "         argument A.",
       "         On exit, the m by n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGEQLF."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "zhetri"=>
  {"summary"=>
    ["ZHETRI computes the inverse of a complex Hermitian indefinite matrix",
     "A using the factorization A = U*D*U**H or A = L*D*L**H computed by",
     "ZHETRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by ZHETRF.",
       "         On exit, if INFO = 0, the (Hermitian) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHETRF."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "zgetrs"=>
  {"summary"=>
    ["ZGETRS solves a system of linear equations",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B",
     "with a general N-by-N matrix A using the LU factorization computed",
     "by ZGETRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by ZGETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from ZGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "chetrs"=>
  {"summary"=>
    ["CHETRS solves a system of linear equations A*X = B with a complex",
     "Hermitian matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by CHETRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CHETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dspgvx"=>
  {"summary"=>
    ["DSPGVX computes selected eigenvalues, and optionally, eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A",
     "and B are assumed to be symmetric, stored in packed storage, and B",
     "is also positive definite.  Eigenvalues and eigenvectors can be",
     "selected by specifying either a range of values or a range of indices",
     "for the desired eigenvalues."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A and B are stored;",
       "         = 'L':  Lower triangle of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix pencil (A,B).  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T, in the same storage",
       "         format as B."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (8*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  DPPTRF or DSPEVX returned an error code:",
       "            <= N:  if INFO = i, DSPEVX failed to converge;",
       "                   i eigenvectors failed to converge.  Their indices",
       "                   are stored in array IFAIL.",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "claswlq"=>
  {"summary"=>
    ["         CLASWLQ computes a blocked Short-Wide LQ factorization of a",
     "         M-by-N matrix A, where N >= M:",
     "         A = L * Q"],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= M >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         M >= MB >= 1"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         NB > M."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and bleow the diagonal",
       "         of the array contain the N-by-N lower triangular matrix L;",
       "         the elements above the diagonal represent Q by the rows",
       "         of blocked V (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array,",
       "         dimension (LDT, N * Number_of_row_blocks)",
       "         where Number_of_row_blocks = CEIL((N-M)/(NB-M))",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.",
       "         See Further Details below."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>
      ["[out]", "        (workspace) COMPLEX array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         The dimension of the array WORK.  LWORK >= MB*M.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ztrsna"=>
  {"summary"=>
    ["ZTRSNA estimates reciprocal condition numbers for specified",
     "eigenvalues and/or right eigenvectors of a complex upper triangular",
     "matrix T (or of any matrix Q*T*Q**H with Q unitary)."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies whether condition numbers are required for",
       "         eigenvalues (S) or eigenvectors (SEP):",
       "         = 'E': for eigenvalues only (S);",
       "         = 'V': for eigenvectors only (SEP);",
       "         = 'B': for both eigenvalues and eigenvectors (S and SEP)."],
     "HOWMNY"=>
      ["[in]",
       "         HOWMNY is CHARACTER*1",
       "         = 'A': compute condition numbers for all eigenpairs;",
       "         = 'S': compute condition numbers for selected eigenpairs",
       "                specified by the array SELECT."],
     "SELECT"=>
      ["[in]",
       "         SELECT is LOGICAL array, dimension (N)",
       "         If HOWMNY = 'S', SELECT specifies the eigenpairs for which",
       "         condition numbers are required. To select condition numbers",
       "         for the j-th eigenpair, SELECT(j) must be set to .TRUE..",
       "         If HOWMNY = 'A', SELECT is not referenced."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix T. N >= 0."],
     "T"=>
      ["[in]",
       "         T is COMPLEX*16 array, dimension (LDT,N)",
       "         The upper triangular matrix T."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is COMPLEX*16 array, dimension (LDVL,M)",
       "         If JOB = 'E' or 'B', VL must contain left eigenvectors of T",
       "         (or of any Q*T*Q**H with Q unitary), corresponding to the",
       "         eigenpairs specified by HOWMNY and SELECT. The eigenvectors",
       "         must be stored in consecutive columns of VL, as returned by",
       "         ZHSEIN or ZTREVC.",
       "         If JOB = 'V', VL is not referenced."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the array VL.",
       "         LDVL >= 1; and if JOB = 'E' or 'B', LDVL >= N."],
     "VR"=>
      ["[in]",
       "         VR is COMPLEX*16 array, dimension (LDVR,M)",
       "         If JOB = 'E' or 'B', VR must contain right eigenvectors of T",
       "         (or of any Q*T*Q**H with Q unitary), corresponding to the",
       "         eigenpairs specified by HOWMNY and SELECT. The eigenvectors",
       "         must be stored in consecutive columns of VR, as returned by",
       "         ZHSEIN or ZTREVC.",
       "         If JOB = 'V', VR is not referenced."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the array VR.",
       "         LDVR >= 1; and if JOB = 'E' or 'B', LDVR >= N."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (MM)",
       "         If JOB = 'E' or 'B', the reciprocal condition numbers of the",
       "         selected eigenvalues, stored in consecutive elements of the",
       "         array. Thus S(j), SEP(j), and the j-th columns of VL and VR",
       "         all correspond to the same eigenpair (but not in general the",
       "         j-th eigenpair, unless all eigenpairs are selected).",
       "         If JOB = 'V', S is not referenced."],
     "SEP"=>
      ["[out]",
       "         SEP is DOUBLE PRECISION array, dimension (MM)",
       "         If JOB = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the selected eigenvectors, stored in consecutive",
       "         elements of the array.",
       "         If JOB = 'E', SEP is not referenced."],
     "MM"=>
      ["[in]",
       "         MM is INTEGER",
       "         The number of elements in the arrays S (if JOB = 'E' or 'B')",
       "          and/or SEP (if JOB = 'V' or 'B'). MM >= M."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The number of elements of the arrays S and/or SEP actually",
       "         used to store the estimated condition numbers.",
       "         If HOWMNY = 'A', M is set to N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (LDWORK,N+6)",
       "         If JOB = 'E', WORK is not referenced."],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         LDWORK >= 1; and if JOB = 'V' or 'B', LDWORK >= N."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (N)",
       "         If JOB = 'E', RWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zpptrs"=>
  {"summary"=>
    ["ZPPTRS solves a system of linear equations A*X = B with a Hermitian",
     "positive definite matrix A in packed storage using the Cholesky",
     "factorization A = U**H * U or A = L * L**H computed by ZPPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H * U or A = L * L**H, packed columnwise in a linear",
       "         array.  The j-th column of U or L is stored in the array AP",
       "         as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zsysv"=>
  {"summary"=>
    ["ZSYSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.  The factored form of A is then",
     "used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**T or A = L*D*L**T as computed by",
       "         ZSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by ZSYTRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         ZSYTRF.",
       "         for LWORK < N, TRS will be done with Level BLAS 2",
       "         for LWORK >= N, TRS will be done with Level BLAS 3",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "zla_hercond_x"=>
  {"summary"=>
    ["   ZLA_HERCOND_X computes the infinity norm condition number of",
     "   op(A) * diag(X) where X is a COMPLEX*16 vector."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by ZHETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by CHETRF."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension (N)",
       "    The vector X in the formula op(A) * diag(X)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX*16 array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is DOUBLE PRECISION array, dimension (N).",
       "    Workspace."]}},
 "zlarft"=>
  {"summary"=>
    ["ZLARFT forms the triangular factor T of a complex block reflector H",
     "of order n, which is defined as a product of k elementary reflectors.",
     "If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;",
     "If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.",
     "If STOREV = 'C', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th column of the array V, and",
     "   H  =  I - V * T * V**H",
     "If STOREV = 'R', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th row of the array V, and",
     "   H  =  I - V**H * T * V"],
   "param"=>
    {"DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies the order in which the elementary reflectors are",
       "         multiplied to form the block reflector:",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Specifies how the vectors which define the elementary",
       "         reflectors are stored (see also Further Details):",
       "         = 'C': columnwise",
       "         = 'R': rowwise"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the block reflector H. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the triangular factor T (= the number of",
       "         elementary reflectors). K >= 1."],
     "V"=>
      ["[in]",
       "         V is COMPLEX*16 array, dimension",
       "                              (LDV,K) if STOREV = 'C'",
       "                              (LDV,N) if STOREV = 'R'",
       "         The matrix V. See further details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,K)",
       "         The k by k triangular factor T of the block reflector.",
       "         If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is",
       "         lower triangular. The rest of the array is not used."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."]}},
 "sgelq2"=>
  {"summary"=>
    ["SGELQ2 computes an LQ factorization of a real m by n matrix A:",
     "A = L * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the m by min(m,n) lower trapezoidal matrix L (L is",
       "         lower triangular if m <= n); the elements above the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dorcsd"=>
  {"summary"=>
    ["DORCSD computes the CS decomposition of an M-by-M partitioned",
     "orthogonal matrix X:",
     "                                [  I  0  0 |  0  0  0 ]",
     "                                [  0  C  0 |  0 -S  0 ]",
     "    [ X11 | X12 ]   [ U1 |    ] [  0  0  0 |  0  0 -I ] [ V1 |    ]**T",
     "X = [-----------] = [---------] [---------------------] [---------]   .",
     "    [ X21 | X22 ]   [    | U2 ] [  0  0  0 |  I  0  0 ] [    | V2 ]",
     "                                [  0  S  0 |  0  C  0 ]",
     "                                [  0  0  I |  0  0  0 ]",
     "X11 is P-by-Q. The orthogonal matrices U1, U2, V1, and V2 are P-by-P,",
     "(M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are",
     "R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in",
     "which R = MIN(P,M-P,Q,M-Q)."],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is computed;",
       "         otherwise:  U1 is not computed."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is computed;",
       "         otherwise:  U2 is not computed."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is computed;",
       "         otherwise:  V1T is not computed."],
     "JOBV2T"=>
      ["[in]",
       "         JOBV2T is CHARACTER",
       "         = 'Y':      V2T is computed;",
       "         otherwise:  V2T is not computed."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "SIGNS"=>
      ["[in]",
       "         SIGNS is CHARACTER",
       "         = 'O':      The lower-left block is made nonpositive (the",
       "                     \"other\" convention);",
       "         otherwise:  The upper-right block is made nonpositive (the",
       "                     \"default\" convention)."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in X11 and X12. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in X11 and X21. 0 <= Q <= M."],
     "X11"=>
      ["[in,out]",
       "         X11 is DOUBLE PRECISION array, dimension (LDX11,Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "         The leading dimension of X11. LDX11 >= MAX(1,P)."],
     "X12"=>
      ["[in,out]",
       "         X12 is DOUBLE PRECISION array, dimension (LDX12,M-Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX12"=>
      ["[in]",
       "         LDX12 is INTEGER",
       "         The leading dimension of X12. LDX12 >= MAX(1,P)."],
     "X21"=>
      ["[in,out]",
       "         X21 is DOUBLE PRECISION array, dimension (LDX21,Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "         The leading dimension of X11. LDX21 >= MAX(1,M-P)."],
     "X22"=>
      ["[in,out]",
       "         X22 is DOUBLE PRECISION array, dimension (LDX22,M-Q)",
       "         On entry, part of the orthogonal matrix whose CSD is desired."],
     "LDX22"=>
      ["[in]",
       "         LDX22 is INTEGER",
       "         The leading dimension of X11. LDX22 >= MAX(1,M-P)."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (R), in which R =",
       "         MIN(P,M-P,Q,M-Q).",
       "         C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and",
       "         S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) )."],
     "U1"=>
      ["[out]",
       "         U1 is DOUBLE PRECISION array, dimension (P)",
       "         If JOBU1 = 'Y', U1 contains the P-by-P orthogonal matrix U1."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of U1. If JOBU1 = 'Y', LDU1 >=",
       "         MAX(1,P)."],
     "U2"=>
      ["[out]",
       "         U2 is DOUBLE PRECISION array, dimension (M-P)",
       "         If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) orthogonal",
       "         matrix U2."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of U2. If JOBU2 = 'Y', LDU2 >=",
       "         MAX(1,M-P)."],
     "V1T"=>
      ["[out]",
       "         V1T is DOUBLE PRECISION array, dimension (Q)",
       "         If JOBV1T = 'Y', V1T contains the Q-by-Q matrix orthogonal",
       "         matrix V1**T."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >=",
       "         MAX(1,Q)."],
     "V2T"=>
      ["[out]",
       "         V2T is DOUBLE PRECISION array, dimension (M-Q)",
       "         If JOBV2T = 'Y', V2T contains the (M-Q)-by-(M-Q) orthogonal",
       "         matrix V2**T."],
     "LDV2T"=>
      ["[in]",
       "         LDV2T is INTEGER",
       "         The leading dimension of V2T. If JOBV2T = 'Y', LDV2T >=",
       "         MAX(1,M-Q)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK.",
       "         If INFO > 0 on exit, WORK(2:R) contains the values PHI(1),",
       "         ..., PHI(R-1) that, together with THETA(1), ..., THETA(R),",
       "         define the matrix in intermediate bidiagonal-block form",
       "         remaining after nonconvergence. INFO specifies the number",
       "         of nonzero PHI's."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the work array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (M-MIN(P, M-P, Q, M-Q))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  DBBCSD did not converge. See the description of WORK",
       "               above for details."]}},
 "sgsvj0"=>
  {"summary"=>
    ["SGSVJ0 is called from SGESVJ as a pre-processor and that is its main",
     "purpose. It applies Jacobi rotations in the same way as SGESVJ does, but",
     "it does not check convergence (stopping criterion). Few tuning",
     "parameters (marked by [TP]) are available for the implementer."],
   "param"=>
    {"JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether the output from this procedure is used",
       "         to compute the matrix V:",
       "         = 'V': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the N-by-N array V.",
       "               (See the description of V.)",
       "         = 'A': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the MV-by-N array V.",
       "               (See the descriptions of MV and V.)",
       "         = 'N': the Jacobi rotations are not accumulated."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, M-by-N matrix A, such that A*diag(D) represents",
       "         the input matrix.",
       "         On exit,",
       "         A_onexit * D_onexit represents the input matrix A*diag(D)",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of D, TOL and NSWEEP.)"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         The array D accumulates the scaling factors from the fast scaled",
       "         Jacobi rotations.",
       "         On entry, A*diag(D) represents the input matrix.",
       "         On exit, A_onexit*diag(D_onexit) represents the input matrix",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of A, TOL and NSWEEP.)"],
     "SVA"=>
      ["[in,out]",
       "         SVA is REAL array, dimension (N)",
       "         On entry, SVA contains the Euclidean norms of the columns of",
       "         the matrix A*diag(D).",
       "         On exit, SVA contains the Euclidean norms of the columns of",
       "         the matrix onexit*diag(D_onexit)."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then MV is not referenced."],
     "V"=>
      ["[in,out]",
       "         V is REAL array, dimension (LDV,N)",
       "         If JOBV .EQ. 'V' then N rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV .EQ. 'A' then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V', LDV .GE. N.",
       "         If JOBV = 'A', LDV .GE. MV."],
     "EPS"=>
      ["[in]", "         EPS is REAL", "         EPS = SLAMCH('Epsilon')"],
     "SFMIN"=>
      ["[in]",
       "         SFMIN is REAL",
       "         SFMIN = SLAMCH('Safe Minimum')"],
     "TOL"=>
      ["[in]",
       "         TOL is REAL",
       "         TOL is the threshold for Jacobi rotations. For a pair",
       "         A(:,p), A(:,q) of pivot columns, the Jacobi rotation is",
       "         applied only if ABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL."],
     "NSWEEP"=>
      ["[in]",
       "         NSWEEP is INTEGER",
       "         NSWEEP is the number of sweeps of Jacobi rotations to be",
       "         performed."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         LWORK is the dimension of WORK. LWORK .GE. M."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value"]}},
 "cunmhr"=>
  {"summary"=>
    ["CUNMHR overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "IHI-ILO elementary reflectors, as returned by CGEHRD:",
     "Q = H(ilo) H(ilo+1) . . . H(ihi-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI must have the same values as in the previous call",
       "         of CGEHRD. Q is equal to the unit matrix except in the",
       "         submatrix Q(ilo+1:ihi,ilo+1:ihi).",
       "         If SIDE = 'L', then 1 <= ILO <= IHI <= M, if M > 0, and",
       "         ILO = 1 and IHI = 0, if M = 0;",
       "         if SIDE = 'R', then 1 <= ILO <= IHI <= N, if N > 0, and",
       "         ILO = 1 and IHI = 0, if N = 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension",
       "                              (LDA,M) if SIDE = 'L'",
       "                              (LDA,N) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by CGEHRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension",
       "                              (M-1) if SIDE = 'L'",
       "                              (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGEHRD."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For optimum performance LWORK >= N*NB if SIDE = 'L', and",
       "         LWORK >= M*NB if SIDE = 'R', where NB is the optimal",
       "         blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cla_porpvgrw"=>
  {"summary"=>
    ["CLA_PORPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A. NCOLS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**T*U or A = L*L**T, as computed by CPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "WORK"=>["[in]", "         WORK is REAL array, dimension (2*N)"]}},
 "spbtf2"=>
  {"summary"=>
    ["SPBTF2 computes the Cholesky factorization of a real symmetric",
     "positive definite band matrix A.",
     "The factorization has the form",
     "   A = U**T * U ,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix, U**T is the transpose of U, and",
     "L is lower triangular.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**T*U or A = L*L**T of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite, and the factorization could not be",
       "              completed."]}},
 "slasd6"=>
  {"summary"=>
    ["SLASD6 computes the SVD of an updated upper bidiagonal matrix B",
     "obtained by merging two smaller ones by appending a row. This",
     "routine is used only for the problem which requires all singular",
     "values and optionally singular vector matrices in factored form.",
     "B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE.",
     "A related subroutine, SLASD1, handles the case in which all singular",
     "values and singular vectors of the bidiagonal matrix are desired.",
     "SLASD6 computes the SVD as follows:",
     "              ( D1(in)    0    0       0 )",
     "  B = U(in) * (   Z1**T   a   Z2**T    b ) * VT(in)",
     "              (   0       0   D2(in)   0 )",
     "    = U(out) * ( D(out) 0) * VT(out)",
     "where Z**T = (Z1**T a Z2**T b) = u**T VT**T, and u is a vector of dimension M",
     "with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros",
     "elsewhere; and the entry b is empty if SQRE = 0.",
     "The singular values of B can be computed using D1, D2, the first",
     "components of all the right singular vectors of the lower block, and",
     "the last components of all the right singular vectors of the upper",
     "block. These components are stored and updated in VF and VL,",
     "respectively, in SLASD6. Hence U and VT are not explicitly",
     "referenced.",
     "The singular values are stored in D. The algorithm consists of two",
     "stages:",
     "      The first stage consists of deflating the size of the problem",
     "      when there are multiple singular values or if there is a zero",
     "      in the Z vector. For each such occurrence the dimension of the",
     "      secular equation problem is reduced by one. This stage is",
     "      performed by the routine SLASD7.",
     "      The second stage consists of calculating the updated",
     "      singular values. This is done by finding the roots of the",
     "      secular equation via the routine SLASD4 (as called by SLASD8).",
     "      This routine also updates VF and VL and computes the distances",
     "      between the updated singular values and the old singular",
     "      values.",
     "SLASD6 is called from SLASDA."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether singular vectors are to be computed in",
       "        factored form:",
       "        = 0: Compute singular values only.",
       "        = 1: Compute singular vectors in factored form as well."],
     "NL"=>
      ["[in]",
       "         NL is INTEGER",
       "        The row dimension of the upper block.  NL >= 1."],
     "NR"=>
      ["[in]",
       "         NR is INTEGER",
       "        The row dimension of the lower block.  NR >= 1."],
     "SQRE"=>
      ["[in]",
       "         SQRE is INTEGER",
       "        = 0: the lower block is an NR-by-NR square matrix.",
       "        = 1: the lower block is an NR-by-(NR+1) rectangular matrix.",
       "        The bidiagonal matrix has row dimension N = NL + NR + 1,",
       "        and column dimension M = N + SQRE."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (NL+NR+1).",
       "        On entry D(1:NL,1:NL) contains the singular values of the",
       "        upper block, and D(NL+2:N) contains the singular values",
       "        of the lower block. On exit D(1:N) contains the singular",
       "        values of the modified matrix."],
     "VF"=>
      ["[in,out]",
       "         VF is REAL array, dimension (M)",
       "        On entry, VF(1:NL+1) contains the first components of all",
       "        right singular vectors of the upper block; and VF(NL+2:M)",
       "        contains the first components of all right singular vectors",
       "        of the lower block. On exit, VF contains the first components",
       "        of all right singular vectors of the bidiagonal matrix."],
     "VL"=>
      ["[in,out]",
       "         VL is REAL array, dimension (M)",
       "        On entry, VL(1:NL+1) contains the  last components of all",
       "        right singular vectors of the upper block; and VL(NL+2:M)",
       "        contains the last components of all right singular vectors of",
       "        the lower block. On exit, VL contains the last components of",
       "        all right singular vectors of the bidiagonal matrix."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is REAL",
       "        Contains the diagonal element associated with the added row."],
     "BETA"=>
      ["[in,out]",
       "         BETA is REAL",
       "        Contains the off-diagonal element associated with the added",
       "        row."],
     "IDXQ"=>
      ["[in,out]",
       "         IDXQ is INTEGER array, dimension (N)",
       "        This contains the permutation which will reintegrate the",
       "        subproblem just solved back into sorted order, i.e.",
       "        D( IDXQ( I = 1, N ) ) will be in ascending order."],
     "PERM"=>
      ["[out]",
       "         PERM is INTEGER array, dimension ( N )",
       "        The permutations (from deflation and sorting) to be applied",
       "        to each block. Not referenced if ICOMPQ = 0."],
     "GIVPTR"=>
      ["[out]",
       "         GIVPTR is INTEGER",
       "        The number of Givens rotations which took place in this",
       "        subproblem. Not referenced if ICOMPQ = 0."],
     "GIVCOL"=>
      ["[out]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation. Not referenced if ICOMPQ = 0."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER",
       "        leading dimension of GIVCOL, must be at least N."],
     "GIVNUM"=>
      ["[out]",
       "         GIVNUM is REAL array, dimension ( LDGNUM, 2 )",
       "        Each number indicates the C or S value to be used in the",
       "        corresponding Givens rotation. Not referenced if ICOMPQ = 0."],
     "LDGNUM"=>
      ["[in]",
       "         LDGNUM is INTEGER",
       "        The leading dimension of GIVNUM and POLES, must be at least N."],
     "POLES"=>
      ["[out]",
       "         POLES is REAL array, dimension ( LDGNUM, 2 )",
       "        On exit, POLES(1,*) is an array containing the new singular",
       "        values obtained from solving the secular equation, and",
       "        POLES(2,*) is an array containing the poles in the secular",
       "        equation. Not referenced if ICOMPQ = 0."],
     "DIFL"=>
      ["[out]",
       "         DIFL is REAL array, dimension ( N )",
       "        On exit, DIFL(I) is the distance between I-th updated",
       "        (undeflated) singular value and the I-th (undeflated) old",
       "        singular value."],
     "DIFR"=>
      ["[out]",
       "         DIFR is REAL array,",
       "                  dimension ( LDDIFR, 2 ) if ICOMPQ = 1 and",
       "                  dimension ( K ) if ICOMPQ = 0.",
       "         On exit, DIFR(I,1) = D(I) - DSIGMA(I+1), DIFR(K,1) is not",
       "         defined and will not be referenced.",
       "         If ICOMPQ = 1, DIFR(1:K,2) is an array containing the",
       "         normalizing factors for the right singular vector matrix.",
       "        See SLASD8 for details on DIFL and DIFR."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension ( M )",
       "        The first elements of this array contain the components",
       "        of the deflation-adjusted updating row vector."],
     "K"=>
      ["[out]",
       "         K is INTEGER",
       "        Contains the dimension of the non-deflated matrix,",
       "        This is the order of the related secular equation. 1 <= K <=N."],
     "C"=>
      ["[out]",
       "         C is REAL",
       "        C contains garbage if SQRE =0 and the C-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "S"=>
      ["[out]",
       "         S is REAL",
       "        S contains garbage if SQRE =0 and the S-value of a Givens",
       "        rotation related to the right null space if SQRE = 1."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension ( 4 * M )"],
     "IWORK"=>
      ["[out]", "         IWORK is INTEGER array, dimension ( 3 * N )"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, a singular value did not converge"]}},
 "csytrf_rk"=>
  {"summary"=>
    ["CSYTRF_RK computes the factorization of a complex symmetric matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the blocked version of the algorithm, calling Level 3 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension ( MAX(1,LWORK) ).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >=1.  For best performance",
       "         LWORK >= N*NB, where NB is the block size returned",
       "         by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array, returns this value as the first entry of the WORK",
       "         array, and no error message related to LWORK is issued",
       "         by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "chetri_3"=>
  {"summary"=>
    ["CHETRI_3 computes the inverse of a complex Hermitian indefinite",
     "matrix A using the factorization computed by CHETRF_RK or CHETRF_BK:",
     "    A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "CHETRI_3 sets the leading dimension of the workspace  before calling",
     "CHETRI_3X that actually computes the inverse.  This is the blocked",
     "version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are",
       "         stored as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, diagonal of the block diagonal matrix D and",
       "         factors U or L as computed by CHETRF_RK and CHETRF_BK:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               should be provided on entry in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         On exit, if INFO = 0, the Hermitian inverse of the original",
       "         matrix.",
       "            If UPLO = 'U': the upper triangular part of the inverse",
       "            is formed and the part of A below the diagonal is not",
       "            referenced;",
       "            If UPLO = 'L': the lower triangular part of the inverse",
       "            is formed and the part of A above the diagonal is not",
       "            referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (N)",
       "         On entry, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;",
       "         If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is not referenced in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF_RK or CHETRF_BK."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (N+NB+1)*(NB+3).",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK. LWORK >= (N+NB+1)*(NB+3).",
       "         If LDWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the optimal",
       "         size of the WORK array, returns this value as the first",
       "         entry of the WORK array, and no error message related to",
       "         LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "slalsd"=>
  {"summary"=>
    ["SLALSD uses the singular value decomposition of A to solve the least",
     "squares problem of finding X to minimize the Euclidean norm of each",
     "column of A*X-B, where A is N-by-N upper bidiagonal, and X and B",
     "are N-by-NRHS. The solution X overwrites B.",
     "The singular values of A smaller than RCOND times the largest",
     "singular value are treated as zero in solving the least squares",
     "problem; in this case a minimum norm solution is returned.",
     "The actual singular values are returned in D in ascending order.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "        = 'U': D and E define an upper bidiagonal matrix.",
       "        = 'L': D and E define a  lower bidiagonal matrix."],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        The maximum size of the subproblems at the bottom of the",
       "        computation tree."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the  bidiagonal matrix.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B. NRHS must be at least 1."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "        On entry D contains the main diagonal of the bidiagonal",
       "        matrix. On exit, if INFO = 0, D contains its singular values."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "        Contains the super-diagonal entries of the bidiagonal matrix.",
       "        On exit, E has been destroyed."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "        On input, B contains the right hand sides of the least",
       "        squares problem. On output, B contains the solution X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B in the calling subprogram.",
       "        LDB must be at least max(1,N)."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "        The singular values of A less than or equal to RCOND times",
       "        the largest singular value are treated as zero in solving",
       "        the least squares problem. If RCOND is negative,",
       "        machine precision is used instead.",
       "        For example, if diag(S)*X=B were the least squares problem,",
       "        where diag(S) is a diagonal matrix of singular values, the",
       "        solution would be X(i) = B(i) / S(i) if S(i) is greater than",
       "        RCOND*max(S), and X(i) = 0 if S(i) is less than or equal to",
       "        RCOND*max(S)."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "        The number of singular values of A greater than RCOND times",
       "        the largest singular value."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension at least",
       "        (9*N + 2*N*SMLSIZ + 8*N*NLVL + N*NRHS + (SMLSIZ+1)**2),",
       "        where NLVL = max(0, INT(log_2 (N/(SMLSIZ+1))) + 1)."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension at least",
       "        (3*N*NLVL + 11*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit.",
       "        < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "        > 0:  The algorithm failed to compute a singular value while",
       "              working on the submatrix lying in rows and columns",
       "              INFO/(N+1) through MOD(INFO,N+1)."]}},
 "zla_gbrcond_c"=>
  {"summary"=>
    ["   ZLA_GBRCOND_C Computes the infinity norm condition number of",
     "   op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "    On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX*16 array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by ZGBTRF.  U is stored as an upper triangular",
       "    band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1,",
       "    and the multipliers used during the factorization are stored",
       "    in rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by ZGBTRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The vector C in the formula op(A) * inv(diag(C))."],
     "CAPPLY"=>
      ["[in]",
       "         CAPPLY is LOGICAL",
       "    If .TRUE. then access the vector C in the formula above."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX*16 array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is DOUBLE PRECISION array, dimension (N).",
       "    Workspace."]}},
 "zheevx_2stage"=>
  {"summary"=>
    ["ZHEEVX_2STAGE computes selected eigenvalues and, optionally, eigenvectors",
     "of a complex Hermitian matrix A using the 2stage technique for",
     "the reduction to tridiagonal.  Eigenvalues and eigenvectors can",
     "be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing A to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*DLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX*16 array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, 8*N, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (7*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "ssytf2_rk"=>
  {"summary"=>
    ["SSYTF2_RK computes the factorization of a real symmetric matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**T)*(P**T) or A = P*L*D*(L**T)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the symmetric block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "dgetrs"=>
  {"summary"=>
    ["DGETRS solves a system of linear equations",
     "   A * X = B  or  A**T * X = B",
     "with a general N-by-N matrix A using the LU factorization computed",
     "by DGETRF."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T* X = B  (Transpose)",
       "         = 'C':  A**T* X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by DGETRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from DGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zla_gercond_x"=>
  {"summary"=>
    ["   ZLA_GERCOND_X computes the infinity norm condition number of",
     "   op(A) * diag(X) where X is a COMPLEX*16 vector."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "    Specifies the form of the system of equations:",
       "      = 'N':  A * X = B     (No transpose)",
       "      = 'T':  A**T * X = B  (Transpose)",
       "      = 'C':  A**H * X = B  (Conjugate Transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by ZGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by ZGETRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension (N)",
       "    The vector X in the formula op(A) * diag(X)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX*16 array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is DOUBLE PRECISION array, dimension (N).",
       "    Workspace."]}},
 "dlangb"=>
  {"summary"=>
    ["DLANGB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n band matrix  A,  with kl sub-diagonals and ku super-diagonals.",
     "   DLANGB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in DLANGB as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, DLANGB is",
       "         set to zero."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The number of sub-diagonals of the matrix A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The number of super-diagonals of the matrix A.  KU >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The band matrix A, stored in rows 1 to KL+KU+1.  The j-th",
       "         column of A is stored in the j-th column of the array AB as",
       "         follows:",
       "         AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl)."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "zppsvx"=>
  {"summary"=>
    ["ZPPSVX uses the Cholesky factorization A = U**H * U or A = L * L**H to",
     "compute the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite matrix stored in",
     "packed format and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "cpstrf"=>
  {"summary"=>
    ["CPSTRF computes the Cholesky factorization with complete",
     "pivoting of a complex Hermitian positive semidefinite matrix A.",
     "The factorization has the form",
     "   P**T * A * P = U**H * U ,  if UPLO = 'U',",
     "   P**T * A * P = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular, and",
     "P is stored as vector PIV.",
     "This algorithm does not attempt to check that A is positive",
     "semidefinite. This version of the algorithm calls level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization as above."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "PIV"=>
      ["[out]",
       "         PIV is INTEGER array, dimension (N)",
       "         PIV is such that the nonzero entries are P( PIV(K), K ) = 1."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The rank of A given by the number of steps the algorithm",
       "         completed."],
     "TOL"=>
      ["[in]",
       "         TOL is REAL",
       "         User defined tolerance. If TOL < 0, then N*U*MAX( A(K,K) )",
       "         will be used. The algorithm terminates at the (K-1)st step",
       "         if the pivot <= TOL."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (2*N)",
       "         Work space."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         < 0: If INFO = -K, the K-th argument had an illegal value,",
       "         = 0: algorithm completed successfully, and",
       "         > 0: the matrix A is either rank deficient with computed rank",
       "              as returned in RANK, or is not positive semidefinite. See",
       "              Section 7 of LAPACK Working Note #161 for further",
       "              information."]}},
 "dpotrf2"=>
  {"summary"=>
    ["DPOTRF2 computes the Cholesky factorization of a real symmetric",
     "positive definite matrix A using the recursive algorithm.",
     "The factorization has the form",
     "   A = U**T * U,  if UPLO = 'U', or",
     "   A = L  * L**T,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the recursive version of the algorithm. It divides",
     "the matrix into four submatrices:",
     "       [  A11 | A12  ]  where A11 is n1 by n1 and A22 is n2 by n2",
     "   A = [ -----|----- ]  with n1 = n/2",
     "       [  A21 | A22  ]       n2 = n-n1",
     "The subroutine calls itself to factor A11. Update and scale A21",
     "or A12, update A22 then calls itself to factor A22."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**T*U or A = L*L**T."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed."]}},
 "sspevx"=>
  {"summary"=>
    ["SSPEVX computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric matrix A in packed storage.  Eigenvalues/vectors",
     "can be selected by specifying either a range of values or a range of",
     "indices for the desired eigenvalues."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found;",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found;",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing AP to tridiagonal form.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*SLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S').",
       "         See \"Computing Small Singular Values of Bidiagonal Matrices",
       "         with Guaranteed High Relative Accuracy,\" by Demmel and",
       "         Kahan, LAPACK Working Note #3."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the selected eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (8*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, then i eigenvectors failed to converge.",
       "               Their indices are stored in array IFAIL."]}},
 "clarz"=>
  {"summary"=>
    ["CLARZ applies a complex elementary reflector H to a complex",
     "M-by-N matrix C, from either the left or the right. H is represented",
     "in the form",
     "      H = I - tau * v * v**H",
     "where tau is a complex scalar and v is a complex vector.",
     "If tau = 0, then H is taken to be the unit matrix.",
     "To apply H**H (the conjugate transpose of H), supply conjg(tau) instead",
     "tau.",
     "H is a product of k elementary reflectors as returned by CTZRZF."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': form  H * C",
       "         = 'R': form  C * H"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of entries of the vector V containing",
       "         the meaningful part of the Householder vectors.",
       "         If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0."],
     "V"=>
      ["[in]",
       "         V is COMPLEX array, dimension (1+(L-1)*abs(INCV))",
       "         The vector v in the representation of H as returned by",
       "         CTZRZF. V is not used if TAU = 0."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between elements of v. INCV <> 0."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX",
       "         The value tau in the representation of H."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by the matrix H * C if SIDE = 'L',",
       "         or C * H if SIDE = 'R'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension",
       "                        (N) if SIDE = 'L'",
       "                     or (M) if SIDE = 'R'"]}},
 "zgebak"=>
  {"summary"=>
    ["ZGEBAK forms the right or left eigenvectors of a complex general",
     "matrix by backward transformation on the computed eigenvectors of the",
     "balanced matrix output by ZGEBAL."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the type of backward transformation required:",
       "         = 'N', do nothing, return immediately;",
       "         = 'P', do backward transformation for permutation only;",
       "         = 'S', do backward transformation for scaling only;",
       "         = 'B', do backward transformations for both permutation and",
       "                scaling.",
       "         JOB must be the same as the argument JOB supplied to ZGEBAL."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  V contains right eigenvectors;",
       "         = 'L':  V contains left eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrix V.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         The integers ILO and IHI determined by ZGEBAL.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "SCALE"=>
      ["[in]",
       "         SCALE is DOUBLE PRECISION array, dimension (N)",
       "         Details of the permutation and scaling factors, as returned",
       "         by ZGEBAL."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix V.  M >= 0."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX*16 array, dimension (LDV,M)",
       "         On entry, the matrix of right or left eigenvectors to be",
       "         transformed, as returned by ZHSEIN or ZTREVC.",
       "         On exit, V is overwritten by the transformed eigenvectors."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slaqp2"=>
  {"summary"=>
    ["SLAQP2 computes a QR factorization with column pivoting of",
     "the block A(OFFSET+1:M,1:N).",
     "The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0."],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         The number of rows of the matrix A that must be pivoted",
       "         but no factorized. OFFSET >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the upper triangle of block A(OFFSET+1:M,1:N) is",
       "         the triangular factor obtained; the elements in block",
       "         A(OFFSET+1:M,1:N) below the diagonal, together with the",
       "         array TAU, represent the orthogonal matrix Q as a product of",
       "         elementary reflectors. Block A(1:OFFSET,1:N) has been",
       "         accordingly pivoted, but no factorized."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "JPVT"=>
      ["[in,out]",
       "         JPVT is INTEGER array, dimension (N)",
       "         On entry, if JPVT(i) .ne. 0, the i-th column of A is permuted",
       "         to the front of A*P (a leading column); if JPVT(i) = 0,",
       "         the i-th column of A is a free column.",
       "         On exit, if JPVT(i) = k, then the i-th column of A*P",
       "         was the k-th column of A."],
     "TAU"=>
      ["[out]",
       "         TAU is REAL array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors."],
     "VN1"=>
      ["[in,out]",
       "         VN1 is REAL array, dimension (N)",
       "         The vector with the partial column norms."],
     "VN2"=>
      ["[in,out]",
       "         VN2 is REAL array, dimension (N)",
       "         The vector with the exact column norms."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"]}},
 "cunmr2"=>
  {"summary"=>
    ["CUNMR2 overwrites the general complex m-by-n matrix C with",
     "      Q * C  if SIDE = 'L' and TRANS = 'N', or",
     "      Q**H* C  if SIDE = 'L' and TRANS = 'C', or",
     "      C * Q  if SIDE = 'R' and TRANS = 'N', or",
     "      C * Q**H if SIDE = 'R' and TRANS = 'C',",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1)**H H(2)**H . . . H(k)**H",
     "as returned by CGERQF. Q is of order m if SIDE = 'L' and of order n",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left",
       "         = 'R': apply Q or Q**H from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension",
       "                              (LDA,M) if SIDE = 'L',",
       "                              (LDA,N) if SIDE = 'R'",
       "         The i-th row must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGERQF in the last k rows of its array argument A.",
       "         A is modified by the routine but restored on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,K)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGERQF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the m-by-n matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension",
       "                                  (N) if SIDE = 'L',",
       "                                  (M) if SIDE = 'R'"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "ztbcon"=>
  {"summary"=>
    ["ZTBCON estimates the reciprocal of the condition number of a",
     "triangular band matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "clalsa"=>
  {"summary"=>
    ["CLALSA is an itermediate step in solving the least squares problem",
     "by computing the SVD of the coefficient matrix in compact form (The",
     "singular vectors are computed as products of simple orthorgonal",
     "matrices.).",
     "If ICOMPQ = 0, CLALSA applies the inverse of the left singular vector",
     "matrix of an upper bidiagonal matrix to the right hand side; and if",
     "ICOMPQ = 1, CLALSA applies the right singular vector matrix to the",
     "right hand side. The singular vector matrices were generated in",
     "compact form by CLALSA."],
   "param"=>
    {"ICOMPQ"=>
      ["[in]",
       "         ICOMPQ is INTEGER",
       "        Specifies whether the left or the right singular vector",
       "        matrix is involved.",
       "        = 0: Left singular vector matrix",
       "        = 1: Right singular vector matrix"],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        The maximum size of the subproblems at the bottom of the",
       "        computation tree."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The row and column dimensions of the upper bidiagonal matrix."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B and BX. NRHS must be at least 1."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension ( LDB, NRHS )",
       "        On input, B contains the right hand sides of the least",
       "        squares problem in rows 1 through M.",
       "        On output, B contains the solution X in rows 1 through N."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B in the calling subprogram.",
       "        LDB must be at least max(1,MAX( M, N ) )."],
     "BX"=>
      ["[out]",
       "         BX is COMPLEX array, dimension ( LDBX, NRHS )",
       "        On exit, the result of applying the left or right singular",
       "        vector matrix to B."],
     "LDBX"=>
      ["[in]",
       "         LDBX is INTEGER",
       "        The leading dimension of BX."],
     "U"=>
      ["[in]",
       "         U is REAL array, dimension ( LDU, SMLSIZ ).",
       "        On entry, U contains the left singular vector matrices of all",
       "        subproblems at the bottom level."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER, LDU = > N.",
       "        The leading dimension of arrays U, VT, DIFL, DIFR,",
       "        POLES, GIVNUM, and Z."],
     "VT"=>
      ["[in]",
       "         VT is REAL array, dimension ( LDU, SMLSIZ+1 ).",
       "        On entry, VT**H contains the right singular vector matrices of",
       "        all subproblems at the bottom level."],
     "K"=>["[in]", "         K is INTEGER array, dimension ( N )."],
     "DIFL"=>
      ["[in]",
       "         DIFL is REAL array, dimension ( LDU, NLVL ).",
       "        where NLVL = INT(log_2 (N/(SMLSIZ+1))) + 1."],
     "DIFR"=>
      ["[in]",
       "         DIFR is REAL array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, DIFL(*, I) and DIFR(*, 2 * I -1) record",
       "        distances between singular values on the I-th level and",
       "        singular values on the (I -1)-th level, and DIFR(*, 2 * I)",
       "        record the normalizing factors of the right singular vectors",
       "        matrices of subproblems on I-th level."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension ( LDU, NLVL ).",
       "        On entry, Z(1, I) contains the components of the deflation-",
       "        adjusted updating row vector for subproblems on the I-th",
       "        level."],
     "POLES"=>
      ["[in]",
       "         POLES is REAL array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, POLES(*, 2 * I -1: 2 * I) contains the new and old",
       "        singular values involved in the secular equations on the I-th",
       "        level."],
     "GIVPTR"=>
      ["[in]",
       "         GIVPTR is INTEGER array, dimension ( N ).",
       "        On entry, GIVPTR( I ) records the number of Givens",
       "        rotations performed on the I-th problem on the computation",
       "        tree."],
     "GIVCOL"=>
      ["[in]",
       "         GIVCOL is INTEGER array, dimension ( LDGCOL, 2 * NLVL ).",
       "        On entry, for each I, GIVCOL(*, 2 * I - 1: 2 * I) records the",
       "        locations of Givens rotations performed on the I-th level on",
       "        the computation tree."],
     "LDGCOL"=>
      ["[in]",
       "         LDGCOL is INTEGER, LDGCOL = > N.",
       "        The leading dimension of arrays GIVCOL and PERM."],
     "PERM"=>
      ["[in]",
       "         PERM is INTEGER array, dimension ( LDGCOL, NLVL ).",
       "        On entry, PERM(*, I) records permutations done on the I-th",
       "        level of the computation tree."],
     "GIVNUM"=>
      ["[in]",
       "         GIVNUM is REAL array, dimension ( LDU, 2 * NLVL ).",
       "        On entry, GIVNUM(*, 2 *I -1 : 2 * I) records the C- and S-",
       "        values of Givens rotations performed on the I-th level on the",
       "        computation tree."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension ( N ).",
       "        On entry, if the I-th subproblem is not square,",
       "        C( I ) contains the C-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension ( N ).",
       "        On entry, if the I-th subproblem is not square,",
       "        S( I ) contains the S-value of a Givens rotation related to",
       "        the right null space of the I-th subproblem."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension at least",
       "        MAX( (SMLSZ+1)*NRHS*3, N*(1+NRHS) + 2*NRHS )."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array.",
       "        The dimension must be at least 3 * N"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dorbdb5"=>
  {"summary"=>[],
   "param"=>
    {"M1"=>
      ["[in]",
       "         M1 is INTEGER",
       "          The dimension of X1 and the number of rows in Q1. 0 <= M1."],
     "M2"=>
      ["[in]",
       "         M2 is INTEGER",
       "          The dimension of X2 and the number of rows in Q2. 0 <= M2."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The number of columns in Q1 and Q2. 0 <= N."],
     "X1"=>
      ["[in,out]",
       "         X1 is DOUBLE PRECISION array, dimension (M1)",
       "          On entry, the top part of the vector to be orthogonalized.",
       "          On exit, the top part of the projected vector."],
     "INCX1"=>
      ["[in]",
       "         INCX1 is INTEGER",
       "          Increment for entries of X1."],
     "X2"=>
      ["[in,out]",
       "         X2 is DOUBLE PRECISION array, dimension (M2)",
       "          On entry, the bottom part of the vector to be",
       "          orthogonalized. On exit, the bottom part of the projected",
       "          vector."],
     "INCX2"=>
      ["[in]",
       "         INCX2 is INTEGER",
       "          Increment for entries of X2."],
     "Q1"=>
      ["[in]",
       "         Q1 is DOUBLE PRECISION array, dimension (LDQ1, N)",
       "          The top part of the orthonormal basis matrix."],
     "LDQ1"=>
      ["[in]",
       "         LDQ1 is INTEGER",
       "          The leading dimension of Q1. LDQ1 >= M1."],
     "Q2"=>
      ["[in]",
       "         Q2 is DOUBLE PRECISION array, dimension (LDQ2, N)",
       "          The bottom part of the orthonormal basis matrix."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "          The leading dimension of Q2. LDQ2 >= M2."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= N."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "dtpttr"=>
  {"summary"=>
    ["DTPTTR copies a triangular matrix A from standard packed format (TP)",
     "to standard full format (TR)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular.",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "A"=>
      ["[out]",
       "         A is DOUBLE PRECISION array, dimension ( LDA, N )",
       "         On exit, the triangular matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlarzt"=>
  {"summary"=>
    ["DLARZT forms the triangular factor T of a real block reflector",
     "H of order > n, which is defined as a product of k elementary",
     "reflectors.",
     "If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;",
     "If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.",
     "If STOREV = 'C', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th column of the array V, and",
     "   H  =  I - V * T * V**T",
     "If STOREV = 'R', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th row of the array V, and",
     "   H  =  I - V**T * T * V",
     "Currently, only STOREV = 'R' and DIRECT = 'B' are supported."],
   "param"=>
    {"DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies the order in which the elementary reflectors are",
       "         multiplied to form the block reflector:",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Specifies how the vectors which define the elementary",
       "         reflectors are stored (see also Further Details):",
       "         = 'C': columnwise                        (not supported yet)",
       "         = 'R': rowwise"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the block reflector H. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the triangular factor T (= the number of",
       "         elementary reflectors). K >= 1."],
     "V"=>
      ["[in,out]",
       "         V is DOUBLE PRECISION array, dimension",
       "                              (LDV,K) if STOREV = 'C'",
       "                              (LDV,N) if STOREV = 'R'",
       "         The matrix V. See further details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i)."],
     "T"=>
      ["[out]",
       "         T is DOUBLE PRECISION array, dimension (LDT,K)",
       "         The k by k triangular factor T of the block reflector.",
       "         If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is",
       "         lower triangular. The rest of the array is not used."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."]}},
 "cppequ"=>
  {"summary"=>
    ["CPPEQU computes row and column scalings intended to equilibrate a",
     "Hermitian positive definite matrix A in packed storage and reduce",
     "its condition number (with respect to the two-norm).  S contains the",
     "scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix",
     "B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal.",
     "This choice of S puts the condition number of B within a factor N of",
     "the smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the Hermitian matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is REAL",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i).  If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix element.  If AMAX is very",
       "         close to overflow or very close to underflow, the matrix",
       "         should be scaled."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "zlaqr1"=>
  {"summary"=>
    ["     Given a 2-by-2 or 3-by-3 matrix H, ZLAQR1 sets v to a",
     "     scalar multiple of the first column of the product",
     "     (*)  K = (H - s1*I)*(H - s2*I)",
     "     scaling to avoid overflows and most underflows.",
     "     This is useful for starting double implicit shift bulges",
     "     in the QR algorithm."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is integer",
       "             Order of the matrix H. N must be either 2 or 3."],
     "H"=>
      ["[in]",
       "         H is COMPLEX*16 array of dimension (LDH,N)",
       "             The 2-by-2 or 3-by-3 matrix H in (*)."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "             The leading dimension of H as declared in",
       "             the calling procedure.  LDH.GE.N"],
     "S1"=>["[in]", "         S1 is COMPLEX*16"],
     "S2"=>
      ["[in]",
       "         S2 is COMPLEX*16",
       "         S1 and S2 are the shifts defining K in (*) above."],
     "V"=>
      ["[out]",
       "         V is COMPLEX*16 array of dimension N",
       "             A scalar multiple of the first column of the",
       "             matrix K in (*)."]}},
 "zla_gbrpvgrw"=>
  {"summary"=>
    ["ZLA_GBRPVGRW computes the reciprocal pivot growth factor",
     "norm(A)/norm(U). The \"max absolute element\" norm is used. If this is",
     "much less than 1, the stability of the LU factorization of the",
     "(equilibrated) matrix A could be poor. This also means that the",
     "solution X, estimated condition numbers, and error bounds could be",
     "unreliable."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0."],
     "NCOLS"=>
      ["[in]",
       "         NCOLS is INTEGER",
       "    The number of columns of the matrix A.  NCOLS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is COMPLEX*16 array, dimension (LDAB,N)",
       "    On entry, the matrix A in band storage, in rows 1 to KL+KU+1.",
       "    The j-th column of A is stored in the j-th column of the",
       "    array AB as follows:",
       "    AB(KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+kl)"],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "    The leading dimension of the array AB.  LDAB >= KL+KU+1."],
     "AFB"=>
      ["[in]",
       "         AFB is COMPLEX*16 array, dimension (LDAFB,N)",
       "    Details of the LU factorization of the band matrix A, as",
       "    computed by ZGBTRF.  U is stored as an upper triangular",
       "    band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1,",
       "    and the multipliers used during the factorization are stored",
       "    in rows KL+KU+2 to 2*KL+KU+1."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AFB.  LDAFB >= 2*KL+KU+1."]}},
 "slartv"=>
  {"summary"=>
    ["SLARTV applies a vector of real plane rotations to elements of the",
     "real vectors x and y. For i = 1,2,...,n",
     "   ( x(i) ) := (  c(i)  s(i) ) ( x(i) )",
     "   ( y(i) )    ( -s(i)  c(i) ) ( y(i) )"],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be applied."],
     "X"=>
      ["[in,out]",
       "         X is REAL array,",
       "                        dimension (1+(N-1)*INCX)",
       "         The vector x."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is REAL array,",
       "                        dimension (1+(N-1)*INCY)",
       "         The vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between elements of Y. INCY > 0."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is REAL array, dimension (1+(N-1)*INCC)",
       "         The sines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C and S. INCC > 0."]}},
 "dlasq1"=>
  {"summary"=>
    ["DLASQ1 computes the singular values of a real N-by-N bidiagonal",
     "matrix with diagonal D and off-diagonal E. The singular values",
     "are computed to high relative accuracy, in the absence of",
     "denormalization, underflow and overflow. The algorithm was first",
     "presented in",
     "\"Accurate singular values and differential qd algorithms\" by K. V.",
     "Fernando and B. N. Parlett, Numer. Math., Vol-67, No. 2, pp. 191-230,",
     "1994,",
     "and the present implementation is described in \"An implementation of",
     "the dqds Algorithm (Positive Case)\", LAPACK Working Note."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "       The number of rows and columns in the matrix. N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "       On entry, D contains the diagonal elements of the",
       "       bidiagonal matrix whose SVD is desired. On normal exit,",
       "       D contains the singular values in decreasing order."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N)",
       "       On entry, elements E(1:N-1) contain the off-diagonal elements",
       "       of the bidiagonal matrix whose SVD is desired.",
       "       On exit, E is overwritten."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "       = 0: successful exit",
       "       < 0: if INFO = -i, the i-th argument had an illegal value",
       "       > 0: the algorithm failed",
       "            = 1, a split was marked by a positive value in E",
       "            = 2, current block of Z not diagonalized after 100*N",
       "                 iterations (in inner while loop)  On exit D and E",
       "                 represent a matrix with the same singular values",
       "                 which the calling subroutine could use to finish the",
       "                 computation, or even feed back into DLASQ1",
       "            = 3, termination criterion of outer while loop not met",
       "                 (program created more than N unreduced blocks)"]}},
 "zgelq"=>
  {"summary"=>["ZGELQ computes a LQ factorization of an M-by-N matrix A."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the M-by-min(M,N) lower trapezoidal matrix L",
       "         (L is lower triangular if M <= N);",
       "         the elements above the diagonal are used to store part of the ",
       "         data structure to represent Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (MAX(5,TSIZE))",
       "         On exit, if INFO = 0, T(1) returns optimal (or either minimal ",
       "         or optimal, if query is assumed) TSIZE. See TSIZE for details.",
       "         Remaining T contains part of the data structure used to represent Q.",
       "         If one wants to apply or construct Q, then one needs to keep T ",
       "         (in addition to A) and pass it to further subroutines."],
     "TSIZE"=>
      ["[in]",
       "         TSIZE is INTEGER",
       "         If TSIZE >= 5, the dimension of the array T.",
       "         If TSIZE = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If TSIZE = -1, the routine calculates optimal size of T for the ",
       "         optimum performance and returns this value in T(1).",
       "         If TSIZE = -2, the routine calculates minimal size of T and ",
       "         returns this value in T(1)."],
     "WORK"=>
      ["[out]",
       "         (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) contains optimal (or either minimal",
       "         or optimal, if query was assumed) LWORK.",
       "         See LWORK for details."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1 or -2, then a workspace query is assumed. The routine",
       "         only calculates the sizes of the T and WORK arrays, returns these",
       "         values as the first entries of the T and WORK arrays, and no error",
       "         message related to T or WORK is issued by XERBLA.",
       "         If LWORK = -1, the routine calculates optimal size of WORK for the",
       "         optimal performance and returns this value in WORK(1).",
       "         If LWORK = -2, the routine calculates minimal size of WORK and ",
       "         returns this value in WORK(1)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlanht"=>
  {"summary"=>
    ["ZLANHT  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex Hermitian tridiagonal matrix A.",
     "   ZLANHT = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANHT as described",
       "         above."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANHT is",
       "         set to zero."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of A."],
     "E"=>
      ["[in]",
       "         E is COMPLEX*16 array, dimension (N-1)",
       "         The (n-1) sub-diagonal or super-diagonal elements of A."]}},
 "csysv_rk"=>
  {"summary"=>
    ["CSYSV_RK computes the solution to a complex system of linear",
     "equations A * X = B, where A is an N-by-N symmetric matrix",
     "and X and B are N-by-NRHS matrices.",
     "The bounded Bunch-Kaufman (rook) diagonal pivoting method is used",
     "to factor A as",
     "   A = P*U*D*(U**T)*(P**T),  if UPLO = 'U', or",
     "   A = P*L*D*(L**T)*(P**T),  if UPLO = 'L',",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**T (or L**T) is the transpose of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is symmetric and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "CSYTRF_RK is called to compute the factorization of a complex",
     "symmetric matrix.  The factored form of A is then used to solve",
     "the system of equations A * X = B by calling BLAS3 routine CSYTRS_3."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, if INFO = 0, diagonal of the block diagonal",
       "         matrix D and factors U or L  as computed by CSYTRF_RK:",
       "           a) ONLY diagonal elements of the symmetric block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A.",
       "         For more info see the description of CSYTRF_RK routine."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX array, dimension (N)",
       "         On exit, contains the output computed by the factorization",
       "         routine CSYTRF_RK, i.e. the superdiagonal (or subdiagonal)",
       "         elements of the symmetric block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases.",
       "         For more info see the description of CSYTRF_RK routine."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D,",
       "         as determined by CSYTRF_RK.",
       "         For more info see the description of CSYTRF_RK routine."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension ( MAX(1,LWORK) ).",
       "         Work array used in the factorization stage.",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1. For best performance",
       "         of factorization stage LWORK >= max(1,N*NB), where NB is",
       "         the optimal blocksize for CSYTRF_RK.",
       "         If LWORK = -1, then a workspace query is assumed;",
       "         the routine only calculates the optimal size of the WORK",
       "         array for factorization stage, returns this value as",
       "         the first entry of the WORK array, and no error message",
       "         related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "dlartv"=>
  {"summary"=>
    ["DLARTV applies a vector of real plane rotations to elements of the",
     "real vectors x and y. For i = 1,2,...,n",
     "   ( x(i) ) := (  c(i)  s(i) ) ( x(i) )",
     "   ( y(i) )    ( -s(i)  c(i) ) ( y(i) )"],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be applied."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array,",
       "                        dimension (1+(N-1)*INCX)",
       "         The vector x."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array,",
       "                        dimension (1+(N-1)*INCY)",
       "         The vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between elements of Y. INCY > 0."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "S"=>
      ["[in]",
       "         S is DOUBLE PRECISION array, dimension (1+(N-1)*INCC)",
       "         The sines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C and S. INCC > 0."]}},
 "clacp2"=>
  {"summary"=>
    ["CLACP2 copies all or part of a real two-dimensional matrix A to a",
     "complex matrix B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the part of the matrix A to be copied to B.",
       "         = 'U':      Upper triangular part",
       "         = 'L':      Lower triangular part",
       "         Otherwise:  All of the matrix A"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         The m by n matrix A.  If UPLO = 'U', only the upper trapezium",
       "         is accessed; if UPLO = 'L', only the lower trapezium is",
       "         accessed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "         On exit, B = A in the locations specified by UPLO."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."]}},
 "zlaswlq"=>
  {"summary"=>
    ["         ZLASWLQ computes a blocked Short-Wide LQ factorization of a",
     "         M-by-N matrix A, where N >= M:",
     "         A = L * Q"],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= M >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         M >= MB >= 1"],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         NB > M."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and bleow the diagonal",
       "         of the array contain the N-by-N lower triangular matrix L;",
       "         the elements above the diagonal represent Q by the rows",
       "         of blocked V (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array,",
       "         dimension (LDT, N * Number_of_row_blocks)",
       "         where Number_of_row_blocks = CEIL((N-M)/(NB-M))",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.",
       "         See Further Details below."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>
      ["[out]",
       "        (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         The dimension of the array WORK.  LWORK >= MB*M.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cbbcsd"=>
  {"summary"=>
    ["CBBCSD computes the CS decomposition of a unitary matrix in",
     "bidiagonal-block form,",
     "    [ B11 | B12 0  0 ]",
     "    [  0  |  0 -I  0 ]",
     "X = [----------------]",
     "    [ B21 | B22 0  0 ]",
     "    [  0  |  0  0  I ]",
     "                              [  C | -S  0  0 ]",
     "                  [ U1 |    ] [  0 |  0 -I  0 ] [ V1 |    ]**H",
     "                = [---------] [---------------] [---------]   .",
     "                  [    | U2 ] [  S |  C  0  0 ] [    | V2 ]",
     "                              [  0 |  0  0  I ]",
     "X is M-by-M, its top-left block is P-by-Q, and Q must be no larger",
     "than P, M-P, or M-Q. (If Q is not the smallest index, then X must be",
     "transposed and/or permuted. This can be done in constant time using",
     "the TRANS and SIGNS options. See CUNCSD for details.)",
     "The bidiagonal matrices B11, B12, B21, and B22 are represented",
     "implicitly by angles THETA(1:Q) and PHI(1:Q-1).",
     "The unitary matrices U1, U2, V1T, and V2T are input/output.",
     "The input matrices are pre- or post-multiplied by the appropriate",
     "singular vector matrices."],
   "param"=>
    {"JOBU1"=>
      ["[in]",
       "         JOBU1 is CHARACTER",
       "         = 'Y':      U1 is updated;",
       "         otherwise:  U1 is not updated."],
     "JOBU2"=>
      ["[in]",
       "         JOBU2 is CHARACTER",
       "         = 'Y':      U2 is updated;",
       "         otherwise:  U2 is not updated."],
     "JOBV1T"=>
      ["[in]",
       "         JOBV1T is CHARACTER",
       "         = 'Y':      V1T is updated;",
       "         otherwise:  V1T is not updated."],
     "JOBV2T"=>
      ["[in]",
       "         JOBV2T is CHARACTER",
       "         = 'Y':      V2T is updated;",
       "         otherwise:  V2T is not updated."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER",
       "         = 'T':      X, U1, U2, V1T, and V2T are stored in row-major",
       "                     order;",
       "         otherwise:  X, U1, U2, V1T, and V2T are stored in column-",
       "                     major order."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows and columns in X, the unitary matrix in",
       "         bidiagonal-block form."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows in the top-left block of X. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "         The number of columns in the top-left block of X.",
       "         0 <= Q <= MIN(P,M-P,M-Q)."],
     "THETA"=>
      ["[in,out]",
       "         THETA is REAL array, dimension (Q)",
       "         On entry, the angles THETA(1),...,THETA(Q) that, along with",
       "         PHI(1), ...,PHI(Q-1), define the matrix in bidiagonal-block",
       "         form. On exit, the angles whose cosines and sines define the",
       "         diagonal blocks in the CS decomposition."],
     "PHI"=>
      ["[in,out]",
       "         PHI is REAL array, dimension (Q-1)",
       "         The angles PHI(1),...,PHI(Q-1) that, along with THETA(1),...,",
       "         THETA(Q), define the matrix in bidiagonal-block form."],
     "U1"=>
      ["[in,out]",
       "         U1 is COMPLEX array, dimension (LDU1,P)",
       "         On entry, a P-by-P matrix. On exit, U1 is postmultiplied",
       "         by the left singular vector matrix common to [ B11 ; 0 ] and",
       "         [ B12 0 0 ; 0 -I 0 0 ]."],
     "LDU1"=>
      ["[in]",
       "         LDU1 is INTEGER",
       "         The leading dimension of the array U1, LDU1 >= MAX(1,P)."],
     "U2"=>
      ["[in,out]",
       "         U2 is COMPLEX array, dimension (LDU2,M-P)",
       "         On entry, an (M-P)-by-(M-P) matrix. On exit, U2 is",
       "         postmultiplied by the left singular vector matrix common to",
       "         [ B21 ; 0 ] and [ B22 0 0 ; 0 0 I ]."],
     "LDU2"=>
      ["[in]",
       "         LDU2 is INTEGER",
       "         The leading dimension of the array U2, LDU2 >= MAX(1,M-P)."],
     "V1T"=>
      ["[in,out]",
       "         V1T is COMPLEX array, dimension (LDV1T,Q)",
       "         On entry, a Q-by-Q matrix. On exit, V1T is premultiplied",
       "         by the conjugate transpose of the right singular vector",
       "         matrix common to [ B11 ; 0 ] and [ B21 ; 0 ]."],
     "LDV1T"=>
      ["[in]",
       "         LDV1T is INTEGER",
       "         The leading dimension of the array V1T, LDV1T >= MAX(1,Q)."],
     "V2T"=>
      ["[in,out]",
       "         V2T is COMPLEX array, dimenison (LDV2T,M-Q)",
       "         On entry, an (M-Q)-by-(M-Q) matrix. On exit, V2T is",
       "         premultiplied by the conjugate transpose of the right",
       "         singular vector matrix common to [ B12 0 0 ; 0 -I 0 ] and",
       "         [ B22 0 0 ; 0 0 I ]."],
     "LDV2T"=>
      ["[in]",
       "         LDV2T is INTEGER",
       "         The leading dimension of the array V2T, LDV2T >= MAX(1,M-Q)."],
     "B11D"=>
      ["[out]",
       "         B11D is REAL array, dimension (Q)",
       "         When CBBCSD converges, B11D contains the cosines of THETA(1),",
       "         ..., THETA(Q). If CBBCSD fails to converge, then B11D",
       "         contains the diagonal of the partially reduced top-left",
       "         block."],
     "B11E"=>
      ["[out]",
       "         B11E is REAL array, dimension (Q-1)",
       "         When CBBCSD converges, B11E contains zeros. If CBBCSD fails",
       "         to converge, then B11E contains the superdiagonal of the",
       "         partially reduced top-left block."],
     "B12D"=>
      ["[out]",
       "         B12D is REAL array, dimension (Q)",
       "         When CBBCSD converges, B12D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If CBBCSD fails to converge, then",
       "         B12D contains the diagonal of the partially reduced top-right",
       "         block."],
     "B12E"=>
      ["[out]",
       "         B12E is REAL array, dimension (Q-1)",
       "         When CBBCSD converges, B12E contains zeros. If CBBCSD fails",
       "         to converge, then B12E contains the subdiagonal of the",
       "         partially reduced top-right block."],
     "B21D"=>
      ["[out]",
       "         B21D is REAL array, dimension (Q)",
       "         When CBBCSD converges, B21D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If CBBCSD fails to converge, then",
       "         B21D contains the diagonal of the partially reduced bottom-left",
       "         block."],
     "B21E"=>
      ["[out]",
       "         B21E is REAL array, dimension (Q-1)",
       "         When CBBCSD converges, B21E contains zeros. If CBBCSD fails",
       "         to converge, then B21E contains the subdiagonal of the",
       "         partially reduced bottom-left block."],
     "B22D"=>
      ["[out]",
       "         B22D is REAL array, dimension (Q)",
       "         When CBBCSD converges, B22D contains the negative sines of",
       "         THETA(1), ..., THETA(Q). If CBBCSD fails to converge, then",
       "         B22D contains the diagonal of the partially reduced bottom-right",
       "         block."],
     "B22E"=>
      ["[out]",
       "         B22E is REAL array, dimension (Q-1)",
       "         When CBBCSD converges, B22E contains zeros. If CBBCSD fails",
       "         to converge, then B22E contains the subdiagonal of the",
       "         partially reduced bottom-right block."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of the array RWORK. LRWORK >= MAX(1,8*Q).",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the RWORK array,",
       "         returns this value as the first entry of the work array, and",
       "         no error message related to LRWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if CBBCSD did not converge, INFO specifies the number",
       "               of nonzero entries in PHI, and B11D, B11E, etc.,",
       "               contain the partially reduced matrix."]}},
 "slatsqr"=>
  {"summary"=>
    ["SLATSQR computes a blocked Tall-Skinny QR factorization of",
     "an M-by-N matrix A, where M >= N:",
     "A = Q * R ."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. M >= N >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The row block size to be used in the blocked QR.",
       "         MB > N."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The column block size to be used in the blocked QR.",
       "         N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal",
       "         of the array contain the N-by-N upper triangular matrix R;",
       "         the elements below the diagonal represent Q by the columns",
       "         of blocked V (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array,",
       "         dimension (LDT, N * Number_of_row_blocks)",
       "         where Number_of_row_blocks = CEIL((M-N)/(MB-N))",
       "         The blocked upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.",
       "         See Further Details below."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>
      ["[out]", "        (workspace) REAL array, dimension (MAX(1,LWORK))"],
     "LWORK"=>
      ["[in]",
       "         The dimension of the array WORK.  LWORK >= NB*N.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dtftri"=>
  {"summary"=>
    ["DTFTRI computes the inverse of a triangular matrix A stored in RFP",
     "format.",
     "This is a Level 3 BLAS version of the algorithm."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'T':  The Transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (0:nt-1);",
       "         nt=N*(N+1)/2. On entry, the triangular factor of a Hermitian",
       "         Positive Definite matrix A in RFP format. RFP format is",
       "         described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'",
       "         then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'T' then RFP is",
       "         the transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the nt elements of",
       "         upper packed A; If UPLO = 'L' the RFP A contains the nt",
       "         elements of lower packed A. The LDA of RFP A is (N+1)/2 when",
       "         TRANSR = 'T'. When TRANSR is 'N' the LDA is N+1 when N is",
       "         even and N is odd. See the Note below for more details.",
       "         On exit, the (triangular) inverse of the original matrix, in",
       "         the same storage format."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, A(i,i) is exactly zero.  The triangular",
       "              matrix is singular and its inverse can not be computed."]}},
 "zporfs"=>
  {"summary"=>
    ["ZPORFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is Hermitian positive definite,",
     "and provides error bounds and backward error estimates for the",
     "solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The Hermitian matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "         The triangular factor U or L from the Cholesky factorization",
       "         A = U**H*U or A = L*L**H, as computed by ZPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by ZPOTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sgebal"=>
  {"summary"=>
    ["SGEBAL balances a general real matrix A.  This involves, first,",
     "permuting A by a similarity transformation to isolate eigenvalues",
     "in the first 1 to ILO-1 and last IHI+1 to N elements on the",
     "diagonal; and second, applying a diagonal similarity transformation",
     "to rows and columns ILO to IHI to make the rows and columns as",
     "close in norm as possible.  Both steps are optional.",
     "Balancing may reduce the 1-norm of the matrix, and improve the",
     "accuracy of the computed eigenvalues and/or eigenvectors."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the operations to be performed on A:",
       "         = 'N':  none:  simply set ILO = 1, IHI = N, SCALE(I) = 1.0",
       "                 for i = 1,...,N;",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the input matrix A.",
       "         On exit,  A is overwritten by the balanced matrix.",
       "         If JOB = 'N', A is not referenced.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are set to integers such that on exit",
       "         A(i,j) = 0 if i > j and j = 1,...,ILO-1 or I = IHI+1,...,N.",
       "         If JOB = 'N' or 'S', ILO = 1 and IHI = N."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied to",
       "         A.  If P(j) is the index of the row and column interchanged",
       "         with row and column j and D(j) is the scaling factor",
       "         applied to row and column j, then",
       "         SCALE(j) = P(j)    for j = 1,...,ILO-1",
       "                  = D(j)    for j = ILO,...,IHI",
       "                  = P(j)    for j = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "stbtrs"=>
  {"summary"=>
    ["STBTRS solves a triangular system of the form",
     "   A * X = B  or  A**T * X = B,",
     "where A is a triangular band matrix of order N, and B is an",
     "N-by NRHS matrix.  A check is made to verify that A is nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of AB.  The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element of A is zero,",
       "               indicating that the matrix is singular and the",
       "               solutions X have not been computed."]}},
 "sptsvx"=>
  {"summary"=>
    ["SPTSVX uses the factorization A = L*D*L**T to compute the solution",
     "to a real system of linear equations A*X = B, where A is an N-by-N",
     "symmetric positive definite tridiagonal matrix and X and B are",
     "N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "dsyequb"=>
  {"summary"=>
    ["DSYEQUB computes row and column scalings intended to equilibrate a",
     "symmetric matrix A (with respect to the Euclidean norm) and reduce",
     "its condition number. The scale factors S are computed by the BIN",
     "algorithm (see references) so that the scaled matrix B with elements",
     "B(i,j) = S(i)*A(i,j)*S(j) has a condition number within a factor N of",
     "the smallest possible condition number over all possible diagonal",
     "scalings."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The N-by-N symmetric matrix whose scaling factors are to be",
       "         computed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "S"=>
      ["[out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, S contains the scale factors for A."],
     "SCOND"=>
      ["[out]",
       "         SCOND is DOUBLE PRECISION",
       "         If INFO = 0, S contains the ratio of the smallest S(i) to",
       "         the largest S(i). If SCOND >= 0.1 and AMAX is neither too",
       "         large nor too small, it is not worth scaling by S."],
     "AMAX"=>
      ["[out]",
       "         AMAX is DOUBLE PRECISION",
       "         Largest absolute value of any matrix element. If AMAX is",
       "         very close to overflow or very close to underflow, the",
       "         matrix should be scaled."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element is nonpositive."]}},
 "iladiag"=>
  {"summary"=>
    ["This subroutine translated from a character string specifying if a",
     "matrix has unit diagonal or not to the relevant BLAST-specified",
     "integer constant.",
     "ILADIAG returns an INTEGER.  If ILADIAG < 0, then the input is not a",
     "character indicating a unit or non-unit diagonal.  Otherwise ILADIAG",
     "returns the constant value corresponding to DIAG."],
   "param"=>nil},
 "dsytri_rook"=>
  {"summary"=>
    ["DSYTRI_ROOK computes the inverse of a real symmetric",
     "matrix A using the factorization A = U*D*U**T or A = L*D*L**T",
     "computed by DSYTRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by DSYTRF_ROOK.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF_ROOK."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "sggevx"=>
  {"summary"=>
    ["SGGEVX computes for a pair of N-by-N real nonsymmetric matrices (A,B)",
     "the generalized eigenvalues, and optionally, the left and/or right",
     "generalized eigenvectors.",
     "Optionally also, it computes a balancing transformation to improve",
     "the conditioning of the eigenvalues and eigenvectors (ILO, IHI,",
     "LSCALE, RSCALE, ABNRM, and BBNRM), reciprocal condition numbers for",
     "the eigenvalues (RCONDE), and reciprocal condition numbers for the",
     "right eigenvectors (RCONDV).",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right eigenvector v(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 A * v(j) = lambda(j) * B * v(j) .",
     "The left eigenvector u(j) corresponding to the eigenvalue lambda(j)",
     "of (A,B) satisfies",
     "                 u(j)**H * A  = lambda(j) * u(j)**H * B.",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"BALANC"=>
      ["[in]",
       "         BALANC is CHARACTER*1",
       "         Specifies the balance option to be performed.",
       "         = 'N':  do not diagonally scale or permute;",
       "         = 'P':  permute only;",
       "         = 'S':  scale only;",
       "         = 'B':  both permute and scale.",
       "         Computed reciprocal condition numbers will be for the",
       "         matrices after permuting and/or balancing. Permuting does",
       "         not change condition numbers (in exact arithmetic), but",
       "         balancing does."],
     "JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "SENSE"=>
      ["[in]",
       "         SENSE is CHARACTER*1",
       "         Determines which reciprocal condition numbers are computed.",
       "         = 'N': none are computed;",
       "         = 'E': computed for eigenvalues only;",
       "         = 'V': computed for eigenvectors only;",
       "         = 'B': computed for eigenvalues and eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten. If JOBVL='V' or JOBVR='V'",
       "         or both, then A contains the first part of the real Schur",
       "         form of the \"balanced\" versions of the input A and B."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten. If JOBVL='V' or JOBVR='V'",
       "         or both, then B contains the second part of the real Schur",
       "         form of the \"balanced\" versions of the input A and B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHAR"=>["[out]", "         ALPHAR is REAL array, dimension (N)"],
     "ALPHAI"=>["[out]", "         ALPHAI is REAL array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is REAL array, dimension (N)",
       "         On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will",
       "         be the generalized eigenvalues.  If ALPHAI(j) is zero, then",
       "         the j-th eigenvalue is real; if positive, then the j-th and",
       "         (j+1)-st eigenvalues are a complex conjugate pair, with",
       "         ALPHAI(j+1) negative.",
       "         Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j)",
       "         may easily over- or underflow, and BETA(j) may even be zero.",
       "         Thus, the user should avoid naively computing the ratio",
       "         ALPHA/BETA. However, ALPHAR and ALPHAI will be always less",
       "         than and usually comparable with norm(A) in magnitude, and",
       "         BETA always less than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is REAL array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left eigenvectors u(j) are stored one",
       "         after another in the columns of VL, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         u(j) = VL(:,j), the j-th column of VL. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         u(j) = VL(:,j)+i*VL(:,j+1) and u(j+1) = VL(:,j)-i*VL(:,j+1).",
       "         Each eigenvector will be scaled so the largest component have",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is REAL array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right eigenvectors v(j) are stored one",
       "         after another in the columns of VR, in the same order as",
       "         their eigenvalues. If the j-th eigenvalue is real, then",
       "         v(j) = VR(:,j), the j-th column of VR. If the j-th and",
       "         (j+1)-th eigenvalues form a complex conjugate pair, then",
       "         v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1).",
       "         Each eigenvector will be scaled so the largest component have",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "ILO"=>["[out]", "         ILO is INTEGER"],
     "IHI"=>
      ["[out]",
       "         IHI is INTEGER",
       "         ILO and IHI are integer values such that on exit",
       "         A(i,j) = 0 and B(i,j) = 0 if i > j and",
       "         j = 1,...,ILO-1 or i = IHI+1,...,N.",
       "         If BALANC = 'N' or 'S', ILO = 1 and IHI = N."],
     "LSCALE"=>
      ["[out]",
       "         LSCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the left side of A and B.  If PL(j) is the index of the",
       "         row interchanged with row j, and DL(j) is the scaling",
       "         factor applied to row j, then",
       "           LSCALE(j) = PL(j)  for j = 1,...,ILO-1",
       "                     = DL(j)  for j = ILO,...,IHI",
       "                     = PL(j)  for j = IHI+1,...,N.",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "RSCALE"=>
      ["[out]",
       "         RSCALE is REAL array, dimension (N)",
       "         Details of the permutations and scaling factors applied",
       "         to the right side of A and B.  If PR(j) is the index of the",
       "         column interchanged with column j, and DR(j) is the scaling",
       "         factor applied to column j, then",
       "           RSCALE(j) = PR(j)  for j = 1,...,ILO-1",
       "                     = DR(j)  for j = ILO,...,IHI",
       "                     = PR(j)  for j = IHI+1,...,N",
       "         The order in which the interchanges are made is N to IHI+1,",
       "         then 1 to ILO-1."],
     "ABNRM"=>
      ["[out]",
       "         ABNRM is REAL",
       "         The one-norm of the balanced matrix A."],
     "BBNRM"=>
      ["[out]",
       "         BBNRM is REAL",
       "         The one-norm of the balanced matrix B."],
     "RCONDE"=>
      ["[out]",
       "         RCONDE is REAL array, dimension (N)",
       "         If SENSE = 'E' or 'B', the reciprocal condition numbers of",
       "         the eigenvalues, stored in consecutive elements of the array.",
       "         For a complex conjugate pair of eigenvalues two consecutive",
       "         elements of RCONDE are set to the same value. Thus RCONDE(j),",
       "         RCONDV(j), and the j-th columns of VL and VR all correspond",
       "         to the j-th eigenpair.",
       "         If SENSE = 'N' or 'V', RCONDE is not referenced."],
     "RCONDV"=>
      ["[out]",
       "         RCONDV is REAL array, dimension (N)",
       "         If SENSE = 'V' or 'B', the estimated reciprocal condition",
       "         numbers of the eigenvectors, stored in consecutive elements",
       "         of the array. For a complex eigenvector two consecutive",
       "         elements of RCONDV are set to the same value. If the",
       "         eigenvalues cannot be reordered to compute RCONDV(j),",
       "         RCONDV(j) is set to 0; this can only occur when the true",
       "         value would be very small anyway.",
       "         If SENSE = 'N' or 'E', RCONDV is not referenced."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,2*N).",
       "         If BALANC = 'S' or 'B', or JOBVL = 'V', or JOBVR = 'V',",
       "         LWORK >= max(1,6*N).",
       "         If SENSE = 'E', LWORK >= max(1,10*N).",
       "         If SENSE = 'V' or 'B', LWORK >= 2*N*N+8*N+16.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (N+6)",
       "         If SENSE = 'E', IWORK is not referenced."],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         If SENSE = 'N', BWORK is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHAR(j), ALPHAI(j), and BETA(j)",
       "               should be correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in SHGEQZ.",
       "               =N+2: error return from STGEVC."]}},
 "zunmhr"=>
  {"summary"=>
    ["ZUNMHR overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix of order nq, with nq = m if",
     "SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of",
     "IHI-ILO elementary reflectors, as returned by ZGEHRD:",
     "Q = H(ilo) H(ilo+1) . . . H(ihi-1)."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply Q  (No transpose)",
       "         = 'C': apply Q**H (Conjugate transpose)"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI must have the same values as in the previous call",
       "         of ZGEHRD. Q is equal to the unit matrix except in the",
       "         submatrix Q(ilo+1:ihi,ilo+1:ihi).",
       "         If SIDE = 'L', then 1 <= ILO <= IHI <= M, if M > 0, and",
       "         ILO = 1 and IHI = 0, if M = 0;",
       "         if SIDE = 'R', then 1 <= ILO <= IHI <= N, if N > 0, and",
       "         ILO = 1 and IHI = 0, if N = 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension",
       "                              (LDA,M) if SIDE = 'L'",
       "                              (LDA,N) if SIDE = 'R'",
       "         The vectors which define the elementary reflectors, as",
       "         returned by ZGEHRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension",
       "                              (M-1) if SIDE = 'L'",
       "                              (N-1) if SIDE = 'R'",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by ZGEHRD."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For optimum performance LWORK >= N*NB if SIDE = 'L', and",
       "         LWORK >= M*NB if SIDE = 'R', where NB is the optimal",
       "         blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dsptrs"=>
  {"summary"=>
    ["DSPTRS solves a system of linear equations A*X = B with a real",
     "symmetric matrix A stored in packed format using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by DSPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by DSPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSPTRF."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "dlarrk"=>
  {"summary"=>
    ["DLARRK computes one eigenvalue of a symmetric tridiagonal",
     "matrix T to suitable accuracy. This is an auxiliary code to be",
     "called from DSTEMR.",
     "To avoid overflow, the matrix must be scaled so that its",
     "largest element is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest",
     "accuracy, it should not be much smaller than that.",
     "See W. Kahan \"Accurate Eigenvalues of a Symmetric Tridiagonal",
     "Matrix\", Report CS41, Computer Science Dept., Stanford",
     "University, July 21, 1966."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix T.  N >= 0."],
     "IW"=>
      ["[in]",
       "         IW is INTEGER",
       "         The index of the eigenvalues to be returned."],
     "GL"=>["[in]", "         GL is DOUBLE PRECISION"],
     "GU"=>
      ["[in]",
       "         GU is DOUBLE PRECISION",
       "         An upper and a lower bound on the eigenvalue."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix T."],
     "E2"=>
      ["[in]",
       "         E2 is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) squared off-diagonal elements of the tridiagonal matrix T."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "         The minimum pivot allowed in the Sturm sequence for T."],
     "RELTOL"=>
      ["[in]",
       "         RELTOL is DOUBLE PRECISION",
       "         The minimum relative width of an interval.  When an interval",
       "         is narrower than RELTOL times the larger (in",
       "         magnitude) endpoint, then it is considered to be",
       "         sufficiently small, i.e., converged.  Note: this should",
       "         always be at least radix*machine epsilon."],
     "W"=>["[out]", "         W is DOUBLE PRECISION"],
     "WERR"=>
      ["[out]",
       "         WERR is DOUBLE PRECISION",
       "         The error bound on the corresponding eigenvalue approximation",
       "         in W."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:       Eigenvalue converged",
       "         = -1:      Eigenvalue did NOT converge"]}},
 "dlasyf"=>
  {"summary"=>
    ["DLASYF computes a partial factorization of a real symmetric matrix A",
     "using the Bunch-Kaufman diagonal pivoting method. The partial",
     "factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**T U22**T )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**T L21**T )  if UPLO = 'L'",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "DLASYF is an auxiliary routine called by DSYTRF. It uses blocked code",
     "(calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or",
     "A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "W"=>
      ["[out]", "         W is DOUBLE PRECISION array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "ctptrs"=>
  {"summary"=>
    ["CTPTRS solves a triangular system of the form",
     "   A * X = B,  A**T * X = B,  or  A**H * X = B,",
     "where A is a triangular matrix of order N stored in packed format,",
     "and B is an N-by-NRHS matrix.  A check is made to verify that A is",
     "nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element of A is zero,",
       "               indicating that the matrix is singular and the",
       "               solutions X have not been computed."]}},
 "clacon"=>
  {"summary"=>
    ["CLACON estimates the 1-norm of a square, complex matrix A.",
     "Reverse communication is used for evaluating matrix-vector products."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "        The order of the matrix.  N >= 1."],
     "V"=>
      ["[out]",
       "         V is COMPLEX array, dimension (N)",
       "        On the final return, V = A*W,  where  EST = norm(V)/norm(W)",
       "        (W is not returned)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (N)",
       "        On an intermediate return, X should be overwritten by",
       "              A * X,   if KASE=1,",
       "              A**H * X,  if KASE=2,",
       "        where A**H is the conjugate transpose of A, and CLACON must be",
       "        re-called with all the other parameters unchanged."],
     "EST"=>
      ["[in,out]",
       "         EST is REAL",
       "        On entry with KASE = 1 or 2 and JUMP = 3, EST should be",
       "        unchanged from the previous call to CLACON.",
       "        On exit, EST is an estimate (a lower bound) for norm(A)."],
     "KASE"=>
      ["[in,out]",
       "         KASE is INTEGER",
       "        On the initial call to CLACON, KASE should be 0.",
       "        On an intermediate return, KASE will be 1 or 2, indicating",
       "        whether X should be overwritten by A * X  or A**H * X.",
       "        On the final return from CLACON, KASE will again be 0."]}},
 "dorbdb1"=>
  {"summary"=>[],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "          The number of rows X11 plus the number of rows in X21."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "          The number of rows in X11. 0 <= P <= M."],
     "Q"=>
      ["[in]",
       "         Q is INTEGER",
       "          The number of columns in X11 and X21. 0 <= Q <=",
       "          MIN(P,M-P,M-Q)."],
     "X11"=>
      ["[in,out]",
       "         X11 is DOUBLE PRECISION array, dimension (LDX11,Q)",
       "          On entry, the top block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X11) specify reflectors for P1 and",
       "          the rows of triu(X11,1) specify reflectors for Q1."],
     "LDX11"=>
      ["[in]",
       "         LDX11 is INTEGER",
       "          The leading dimension of X11. LDX11 >= P."],
     "X21"=>
      ["[in,out]",
       "         X21 is DOUBLE PRECISION array, dimension (LDX21,Q)",
       "          On entry, the bottom block of the matrix X to be reduced. On",
       "          exit, the columns of tril(X21) specify reflectors for P2."],
     "LDX21"=>
      ["[in]",
       "         LDX21 is INTEGER",
       "          The leading dimension of X21. LDX21 >= M-P."],
     "THETA"=>
      ["[out]",
       "         THETA is DOUBLE PRECISION array, dimension (Q)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "PHI"=>
      ["[out]",
       "         PHI is DOUBLE PRECISION array, dimension (Q-1)",
       "          The entries of the bidiagonal blocks B11, B21 are defined by",
       "          THETA and PHI. See Further Details."],
     "TAUP1"=>
      ["[out]",
       "         TAUP1 is DOUBLE PRECISION array, dimension (P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P1."],
     "TAUP2"=>
      ["[out]",
       "         TAUP2 is DOUBLE PRECISION array, dimension (M-P)",
       "          The scalar factors of the elementary reflectors that define",
       "          P2."],
     "TAUQ1"=>
      ["[out]",
       "         TAUQ1 is DOUBLE PRECISION array, dimension (Q)",
       "          The scalar factors of the elementary reflectors that define",
       "          Q1."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK. LWORK >= M-Q.",
       "          If LWORK = -1, then a workspace query is assumed; the routine",
       "          only calculates the optimal size of the WORK array, returns",
       "          this value as the first entry of the WORK array, and no error",
       "          message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          = 0:  successful exit.",
       "          < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "ilatrans"=>
  {"summary"=>
    ["This subroutine translates from a character string specifying a",
     "transposition operation to the relevant BLAST-specified integer",
     "constant.",
     "ILATRANS returns an INTEGER.  If ILATRANS < 0, then the input is not",
     "a character indicating a transposition operator.  Otherwise ILATRANS",
     "returns the constant value corresponding to TRANS."],
   "param"=>nil},
 "dgtcon"=>
  {"summary"=>
    ["DGTCON estimates the reciprocal of the condition number of a real",
     "tridiagonal matrix A using the LU factorization as computed by",
     "DGTTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "DL"=>
      ["[in]",
       "         DL is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A as computed by DGTTRF."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DU"=>
      ["[in]",
       "         DU is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) elements of the first superdiagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is DOUBLE PRECISION array, dimension (N-2)",
       "         The (n-2) elements of the second superdiagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         If NORM = '1' or 'O', the 1-norm of the original matrix A.",
       "         If NORM = 'I', the infinity-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgesvd"=>
  {"summary"=>
    ["CGESVD computes the singular value decomposition (SVD) of a complex",
     "M-by-N matrix A, optionally computing the left and/or right singular",
     "vectors. The SVD is written",
     "     A = U * SIGMA * conjugate-transpose(V)",
     "where SIGMA is an M-by-N matrix which is zero except for its",
     "min(m,n) diagonal elements, U is an M-by-M unitary matrix, and",
     "V is an N-by-N unitary matrix.  The diagonal elements of SIGMA",
     "are the singular values of A; they are real and non-negative, and",
     "are returned in descending order.  The first min(m,n) columns of",
     "U and V are the left and right singular vectors of A.",
     "Note that the routine returns V**H, not V."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix U:",
       "         = 'A':  all M columns of U are returned in array U:",
       "         = 'S':  the first min(m,n) columns of U (the left singular",
       "                 vectors) are returned in the array U;",
       "         = 'O':  the first min(m,n) columns of U (the left singular",
       "                 vectors) are overwritten on the array A;",
       "         = 'N':  no columns of U (no left singular vectors) are",
       "                 computed."],
     "JOBVT"=>
      ["[in]",
       "         JOBVT is CHARACTER*1",
       "         Specifies options for computing all or part of the matrix",
       "         V**H:",
       "         = 'A':  all N rows of V**H are returned in the array VT;",
       "         = 'S':  the first min(m,n) rows of V**H (the right singular",
       "                 vectors) are returned in the array VT;",
       "         = 'O':  the first min(m,n) rows of V**H (the right singular",
       "                 vectors) are overwritten on the array A;",
       "         = 'N':  no rows of V**H (no right singular vectors) are",
       "                 computed.",
       "         JOBVT and JOBU cannot both be 'O'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit,",
       "         if JOBU = 'O',  A is overwritten with the first min(m,n)",
       "                         columns of U (the left singular vectors,",
       "                         stored columnwise);",
       "         if JOBVT = 'O', A is overwritten with the first min(m,n)",
       "                         rows of V**H (the right singular vectors,",
       "                         stored rowwise);",
       "         if JOBU .ne. 'O' and JOBVT .ne. 'O', the contents of A",
       "                         are destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (min(M,N))",
       "         The singular values of A, sorted so that S(i) >= S(i+1)."],
     "U"=>
      ["[out]",
       "         U is COMPLEX array, dimension (LDU,UCOL)",
       "         (LDU,M) if JOBU = 'A' or (LDU,min(M,N)) if JOBU = 'S'.",
       "         If JOBU = 'A', U contains the M-by-M unitary matrix U;",
       "         if JOBU = 'S', U contains the first min(m,n) columns of U",
       "         (the left singular vectors, stored columnwise);",
       "         if JOBU = 'N' or 'O', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= 1; if",
       "         JOBU = 'S' or 'A', LDU >= M."],
     "VT"=>
      ["[out]",
       "         VT is COMPLEX array, dimension (LDVT,N)",
       "         If JOBVT = 'A', VT contains the N-by-N unitary matrix",
       "         V**H;",
       "         if JOBVT = 'S', VT contains the first min(m,n) rows of",
       "         V**H (the right singular vectors, stored rowwise);",
       "         if JOBVT = 'N' or 'O', VT is not referenced."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.  LDVT >= 1; if",
       "         JOBVT = 'A', LDVT >= N; if JOBVT = 'S', LDVT >= min(M,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         LWORK >=  MAX(1,2*MIN(M,N)+MAX(M,N)).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (5*min(M,N))",
       "         On exit, if INFO > 0, RWORK(1:MIN(M,N)-1) contains the",
       "         unconverged superdiagonal elements of an upper bidiagonal",
       "         matrix B whose diagonal is in S (not necessarily sorted).",
       "         B satisfies A = U * B * VT, so it has the same singular",
       "         values as A, and singular vectors related by U and VT."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if CBDSQR did not converge, INFO specifies how many",
       "               superdiagonals of an intermediate bidiagonal form B",
       "               did not converge to zero. See the description of RWORK",
       "               above for details."]}},
 "slasd5"=>
  {"summary"=>
    ["This subroutine computes the square root of the I-th eigenvalue",
     "of a positive symmetric rank-one modification of a 2-by-2 diagonal",
     "matrix",
     "           diag( D ) * diag( D ) +  RHO * Z * transpose(Z) .",
     "The diagonal entries in the array D are assumed to satisfy",
     "           0 <= D(i) < D(j)  for  i < j .",
     "We also assume RHO > 0 and that the Euclidean norm of the vector",
     "Z is one."],
   "param"=>
    {"I"=>
      ["[in]",
       "         I is INTEGER",
       "        The index of the eigenvalue to be computed.  I = 1 or I = 2."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (2)",
       "        The original eigenvalues.  We assume 0 <= D(1) < D(2)."],
     "Z"=>
      ["[in]",
       "         Z is REAL array, dimension (2)",
       "        The components of the updating vector."],
     "DELTA"=>
      ["[out]",
       "         DELTA is REAL array, dimension (2)",
       "        Contains (D(j) - sigma_I) in its  j-th component.",
       "        The vector DELTA contains the information necessary",
       "        to construct the eigenvectors."],
     "RHO"=>
      ["[in]",
       "         RHO is REAL",
       "        The scalar in the symmetric updating formula."],
     "DSIGMA"=>
      ["[out]",
       "         DSIGMA is REAL",
       "        The computed sigma_I, the I-th updated eigenvalue."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (2)",
       "        WORK contains (D(j) + sigma_I) in its  j-th component."]}},
 "clauum"=>
  {"summary"=>
    ["CLAUUM computes the product U * U**H or L**H * L, where the triangular",
     "factor U or L is stored in the upper or lower triangular part of",
     "the array A.",
     "If UPLO = 'U' or 'u' then the upper triangle of the result is stored,",
     "overwriting the factor U in A.",
     "If UPLO = 'L' or 'l' then the lower triangle of the result is stored,",
     "overwriting the factor L in A.",
     "This is the blocked form of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the triangular factor stored in the array A",
       "         is upper or lower triangular:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the triangular factor U or L.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L.",
       "         On exit, if UPLO = 'U', the upper triangle of A is",
       "         overwritten with the upper triangle of the product U * U**H;",
       "         if UPLO = 'L', the lower triangle of A is overwritten with",
       "         the lower triangle of the product L**H * L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value"]}},
 "chetf2_rk"=>
  {"summary"=>
    ["CHETF2_RK computes the factorization of a complex Hermitian matrix A",
     "using the bounded Bunch-Kaufman (rook) diagonal pivoting method:",
     "   A = P*U*D*(U**H)*(P**T) or A = P*L*D*(L**H)*(P**T),",
     "where U (or L) is unit upper (or lower) triangular matrix,",
     "U**H (or L**H) is the conjugate of U (or L), P is a permutation",
     "matrix, P**T is the transpose of P, and D is Hermitian and block",
     "diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS.",
     "For more information see Further Details section."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the Hermitian block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step. For more info see Further",
       "         Details section.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the matrix A(1:N,1:N).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the matrix A(1:N,1:N).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b), always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "chpgv"=>
  {"summary"=>
    ["CHPGV computes all the eigenvalues and, optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be Hermitian, stored in packed format,",
     "and B is also positive definite."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, the contents of AP are destroyed."],
     "BP"=>
      ["[in,out]",
       "         BP is COMPLEX array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the Hermitian matrix",
       "         B, packed columnwise in a linear array.  The j-th column of B",
       "         is stored in the array BP as follows:",
       "         if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.",
       "         On exit, the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H, in the same storage",
       "         format as B."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors.  The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX array, dimension (max(1, 2*N-1))"],
     "RWORK"=>
      ["[out]", "         RWORK is REAL array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  CPPTRF or CHPEV returned an error code:",
       "            <= N:  if INFO = i, CHPEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not convergeto zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= n, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "ztrrfs"=>
  {"summary"=>
    ["ZTRRFS provides error bounds and backward error estimates for the",
     "solution to a system of linear equations with a triangular",
     "coefficient matrix.",
     "The solution matrix X must be computed by ZTRTRS or some other",
     "means before entering this routine.  ZTRRFS does not do iterative",
     "refinement because doing so cannot improve the backward error."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The triangular matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of the array A contains the upper",
       "         triangular matrix, and the strictly lower triangular part of",
       "         A is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of the array A contains the lower triangular",
       "         matrix, and the strictly upper triangular part of A is not",
       "         referenced.  If DIAG = 'U', the diagonal elements of A are",
       "         also not referenced and are assumed to be 1."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         The solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgeqrf"=>
  {"summary"=>
    ["DGEQRF computes a QR factorization of a real M-by-N matrix A:",
     "A = Q * R."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n); the elements below the diagonal,",
       "         with the array TAU, represent the orthogonal matrix Q as a",
       "         product of min(m,n) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zhegv_2stage"=>
  {"summary"=>
    ["ZHEGV_2STAGE computes all the eigenvalues, and optionally, the eigenvectors",
     "of a complex generalized Hermitian-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.",
     "Here A and B are assumed to be Hermitian and B is also",
     "positive definite.",
     "This routine use the 2stage technique for the reduction to tridiagonal",
     "which showed higher performance on recent architecture and for large"],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors.",
       "                 Not available in this release."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA, N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, if JOBZ = 'V', then if INFO = 0, A contains the",
       "         matrix Z of eigenvectors.  The eigenvectors are normalized",
       "         as follows:",
       "         if ITYPE = 1 or 2, Z**H*B*Z = I;",
       "         if ITYPE = 3, Z**H*inv(B)*Z = I.",
       "         If JOBZ = 'N', then on exit the upper triangle (if UPLO='U')",
       "         or the lower triangle (if UPLO='L') of A, including the",
       "         diagonal, is destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB, N)",
       "         On entry, the Hermitian positive definite matrix B.",
       "         If UPLO = 'U', the leading N-by-N upper triangular part of B",
       "         contains the upper triangular part of the matrix B.",
       "         If UPLO = 'L', the leading N-by-N lower triangular part of B",
       "         contains the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**H*U or B = L*L**H."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK. LWORK >= 1, when N <= 1;",
       "         otherwise  ",
       "         If JOBZ = 'N' and N > 1, LWORK must be queried.",
       "                                  LWORK = MAX(1, dimension) where",
       "                                  dimension = max(stage1,stage2) + (KD+1)*N + N",
       "                                            = N*KD + N*max(KD+1,FACTOPTNB) ",
       "                                              + max(2*KD*KD, KD*NTHREADS) ",
       "                                              + (KD+1)*N + N",
       "                                  where KD is the blocking size of the reduction,",
       "                                  FACTOPTNB is the blocking used by the QR or LQ",
       "                                  algorithm, usually FACTOPTNB=128 is a good choice",
       "                                  NTHREADS is the number of threads used when",
       "                                  openMP compilation is enabled, otherwise =1.",
       "         If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is DOUBLE PRECISION array, dimension (max(1, 3*N-2))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  ZPOTRF or ZHEEV returned an error code:",
       "            <= N:  if INFO = i, ZHEEV failed to converge;",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "cggev3"=>
  {"summary"=>
    ["CGGEV3 computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, and optionally, the left and/or",
     "right generalized eigenvectors.",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar",
     "lambda or a ratio alpha/beta = lambda, such that A - lambda*B is",
     "singular. It is usually represented as the pair (alpha,beta), as",
     "there is a reasonable interpretation for beta=0, and even for both",
     "being zero.",
     "The right generalized eigenvector v(j) corresponding to the",
     "generalized eigenvalue lambda(j) of (A,B) satisfies",
     "             A * v(j) = lambda(j) * B * v(j).",
     "The left generalized eigenvector u(j) corresponding to the",
     "generalized eigenvalues lambda(j) of (A,B) satisfies",
     "             u(j)**H * A = lambda(j) * u(j)**H * B",
     "where u(j)**H is the conjugate-transpose of u(j)."],
   "param"=>
    {"JOBVL"=>
      ["[in]",
       "         JOBVL is CHARACTER*1",
       "         = 'N':  do not compute the left generalized eigenvectors;",
       "         = 'V':  compute the left generalized eigenvectors."],
     "JOBVR"=>
      ["[in]",
       "         JOBVR is CHARACTER*1",
       "         = 'N':  do not compute the right generalized eigenvectors;",
       "         = 'V':  compute the right generalized eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VL, and VR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the matrix A in the pair (A,B).",
       "         On exit, A has been overwritten."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the matrix B in the pair (A,B).",
       "         On exit, B has been overwritten."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX array, dimension (N)",
       "         On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the",
       "         generalized eigenvalues.",
       "         Note: the quotients ALPHA(j)/BETA(j) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio alpha/beta.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VL"=>
      ["[out]",
       "         VL is COMPLEX array, dimension (LDVL,N)",
       "         If JOBVL = 'V', the left generalized eigenvectors u(j) are",
       "         stored one after another in the columns of VL, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVL = 'N'."],
     "LDVL"=>
      ["[in]",
       "         LDVL is INTEGER",
       "         The leading dimension of the matrix VL. LDVL >= 1, and",
       "         if JOBVL = 'V', LDVL >= N."],
     "VR"=>
      ["[out]",
       "         VR is COMPLEX array, dimension (LDVR,N)",
       "         If JOBVR = 'V', the right generalized eigenvectors v(j) are",
       "         stored one after another in the columns of VR, in the same",
       "         order as their eigenvalues.",
       "         Each eigenvector is scaled so the largest component has",
       "         abs(real part) + abs(imag. part) = 1.",
       "         Not referenced if JOBVR = 'N'."],
     "LDVR"=>
      ["[in]",
       "         LDVR is INTEGER",
       "         The leading dimension of the matrix VR. LDVR >= 1, and",
       "         if JOBVR = 'V', LDVR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (8*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         =1,...,N:",
       "               The QZ iteration failed.  No eigenvectors have been",
       "               calculated, but ALPHA(j) and BETA(j) should be",
       "               correct for j=INFO+1,...,N.",
       "         > N:  =N+1: other then QZ iteration failed in SHGEQZ,",
       "               =N+2: error return from STGEVC."]}},
 "cspsvx"=>
  {"summary"=>
    ["CSPSVX uses the diagonal pivoting factorization A = U*D*U**T or",
     "A = L*D*L**T to compute the solution to a complex system of linear",
     "equations A * X = B, where A is an N-by-N symmetric matrix stored",
     "in packed format and X and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "zsptri"=>
  {"summary"=>
    ["ZSPTRI computes the inverse of a complex symmetric indefinite matrix",
     "A in packed storage using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by ZSPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by ZSPTRF,",
       "         stored as a packed triangular matrix.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix, stored as a packed triangular matrix. The j-th column",
       "         of inv(A) is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;",
       "         if UPLO = 'L',",
       "            AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSPTRF."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "dpttrf"=>
  {"summary"=>
    ["DPTTRF computes the L*D*L**T factorization of a real symmetric",
     "positive definite tridiagonal matrix A.  The factorization may also",
     "be regarded as having the form A = U**T*D*U."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         On entry, the n diagonal elements of the tridiagonal matrix",
       "         A.  On exit, the n diagonal elements of the diagonal matrix",
       "         D from the L*D*L**T factorization of A."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         On entry, the (n-1) subdiagonal elements of the tridiagonal",
       "         matrix A.  On exit, the (n-1) subdiagonal elements of the",
       "         unit bidiagonal factor L from the L*D*L**T factorization of A.",
       "         E can also be regarded as the superdiagonal of the unit",
       "         bidiagonal factor U from the U**T*D*U factorization of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite; if k < N, the factorization could not",
       "              be completed, while if k = N, the factorization was",
       "              completed, but D(N) <= 0."]}},
 "zspr"=>
  {"summary"=>
    ["ZSPR    performs the symmetric rank 1 operation",
     "   A := alpha*x*x**H + A,",
     "where alpha is a complex scalar, x is an n element vector and A is an",
     "n by n symmetric matrix, supplied in packed form."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the upper or lower",
       "          triangular part of the matrix A is supplied in the packed",
       "          array AP as follows:",
       "             UPLO = 'U' or 'u'   The upper triangular part of A is",
       "                                 supplied in AP.",
       "             UPLO = 'L' or 'l'   The lower triangular part of A is",
       "                                 supplied in AP.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the order of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX*16",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array, dimension at least",
       "          ( 1 + ( N - 1 )*abs( INCX ) ).",
       "          Before entry, the incremented array X must contain the N-",
       "          element vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "AP"=>
      ["[in,out]",
       "         AP is COMPLEX*16 array, dimension at least",
       "          ( ( N*( N + 1 ) )/2 ).",
       "          Before entry, with  UPLO = 'U' or 'u', the array AP must",
       "          contain the upper triangular part of the symmetric matrix",
       "          packed sequentially, column by column, so that AP( 1 )",
       "          contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 )",
       "          and a( 2, 2 ) respectively, and so on. On exit, the array",
       "          AP is overwritten by the upper triangular part of the",
       "          updated matrix.",
       "          Before entry, with UPLO = 'L' or 'l', the array AP must",
       "          contain the lower triangular part of the symmetric matrix",
       "          packed sequentially, column by column, so that AP( 1 )",
       "          contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 )",
       "          and a( 3, 1 ) respectively, and so on. On exit, the array",
       "          AP is overwritten by the lower triangular part of the",
       "          updated matrix.",
       "          Note that the imaginary parts of the diagonal elements need",
       "          not be set, they are assumed to be zero, and on exit they",
       "          are set to zero."]}},
 "ssysv"=>
  {"summary"=>
    ["SSYSV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric matrix and X and B are N-by-NRHS",
     "matrices.",
     "The diagonal pivoting method is used to factor A as",
     "   A = U * D * U**T,  if UPLO = 'U', or",
     "   A = L * D * L**T,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and D is symmetric and block diagonal with",
     "1-by-1 and 2-by-2 diagonal blocks.  The factored form of A is then",
     "used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the block diagonal matrix D and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*D*U**T or A = L*D*L**T as computed by",
       "         SSYTRF."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D, as",
       "         determined by SSYTRF.  If IPIV(k) > 0, then rows and columns",
       "         k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1",
       "         diagonal block.  If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,",
       "         then rows and columns k-1 and -IPIV(k) were interchanged and",
       "         D(k-1:k,k-1:k) is a 2-by-2 diagonal block.  If UPLO = 'L' and",
       "         IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and",
       "         -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2",
       "         diagonal block."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= 1, and for best performance",
       "         LWORK >= max(1,N*NB), where NB is the optimal blocksize for",
       "         SSYTRF.",
       "         for LWORK < N, TRS will be done with Level BLAS 2",
       "         for LWORK >= N, TRS will be done with Level BLAS 3",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "zlacpy"=>
  {"summary"=>
    ["ZLACPY copies all or part of a two-dimensional matrix A to another",
     "matrix B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the part of the matrix A to be copied to B.",
       "         = 'U':      Upper triangular part",
       "         = 'L':      Lower triangular part",
       "         Otherwise:  All of the matrix A"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The m by n matrix A.  If UPLO = 'U', only the upper trapezium",
       "         is accessed; if UPLO = 'L', only the lower trapezium is",
       "         accessed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "B"=>
      ["[out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On exit, B = A in the locations specified by UPLO."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."]}},
 "dorgl2"=>
  {"summary"=>
    ["DORGL2 generates an m by n real matrix Q with orthonormal rows,",
     "which is defined as the first m rows of a product of k elementary",
     "reflectors of order n",
     "      Q  =  H(k) . . . H(2) H(1)",
     "as returned by DGELQF."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix Q. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix Q. N >= M."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines the",
       "         matrix Q. M >= K >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the i-th row must contain the vector which defines",
       "         the elementary reflector H(i), for i = 1,2,...,k, as returned",
       "         by DGELQF in the first k rows of its array argument A.",
       "         On exit, the m-by-n matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The first dimension of the array A. LDA >= max(1,M)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGELQF."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (M)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument has an illegal value"]}},
 "stptrs"=>
  {"summary"=>
    ["STPTRS solves a triangular system of the form",
     "   A * X = B  or  A**T * X = B,",
     "where A is a triangular matrix of order N stored in packed format,",
     "and B is an N-by-NRHS matrix.  A check is made to verify that A is",
     "nonsingular."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B  (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, if INFO = 0, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the i-th diagonal element of A is zero,",
       "               indicating that the matrix is singular and the",
       "               solutions X have not been computed."]}},
 "cggglm"=>
  {"summary"=>
    ["CGGGLM solves a general Gauss-Markov linear model (GLM) problem:",
     "        minimize || y ||_2   subject to   d = A*x + B*y",
     "            x",
     "where A is an N-by-M matrix, B is an N-by-P matrix, and d is a",
     "given N-vector. It is assumed that M <= N <= M+P, and",
     "           rank(A) = M    and    rank( A B ) = N.",
     "Under these assumptions, the constrained equation is always",
     "consistent, and there is a unique solution x and a minimal 2-norm",
     "solution y, which is obtained using a generalized QR factorization",
     "of the matrices (A, B) given by",
     "   A = Q*(R),   B = Q*T*Z.",
     "         (0)",
     "In particular, if matrix B is square nonsingular, then the problem",
     "GLM is equivalent to the following weighted linear least squares",
     "problem",
     "             minimize || inv(B)*(d-A*x) ||_2",
     "                 x",
     "where inv(B) denotes the inverse of B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrices A and B.  N >= 0."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix A.  0 <= M <= N."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of columns of the matrix B.  P >= N-M."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,M)",
       "         On entry, the N-by-M matrix A.",
       "         On exit, the upper triangular part of the array A contains",
       "         the M-by-M upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,P)",
       "         On entry, the N-by-P matrix B.",
       "         On exit, if N <= P, the upper triangle of the subarray",
       "         B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T;",
       "         if N > P, the elements on and above the (N-P)th subdiagonal",
       "         contain the N-by-P upper trapezoidal matrix T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,N)."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX array, dimension (N)",
       "         On entry, D is the left hand side of the GLM equation.",
       "         On exit, D is destroyed."],
     "X"=>["[out]", "         X is COMPLEX array, dimension (M)"],
     "Y"=>
      ["[out]",
       "         Y is COMPLEX array, dimension (P)",
       "         On exit, X and Y are the solutions of the GLM problem."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N+M+P).",
       "         For optimum performance, LWORK >= M+min(N,P)+max(N,P)*NB,",
       "         where NB is an upper bound for the optimal blocksizes for",
       "         CGEQRF, CGERQF, CUNMQR and CUNMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the upper triangular factor R associated with A in the",
       "               generalized QR factorization of the pair (A, B) is",
       "               singular, so that rank(A) < M; the least squares",
       "               solution could not be computed.",
       "         = 2:  the bottom (N-M) by (N-M) part of the upper trapezoidal",
       "               factor T associated with B in the generalized QR",
       "               factorization of the pair (A, B) is singular, so that",
       "               rank( A B ) < N; the least squares solution could not",
       "               be computed."]}},
 "cstemr"=>
  {"summary"=>
    ["CSTEMR computes selected eigenvalues and, optionally, eigenvectors",
     "of a real symmetric tridiagonal matrix T. Any such unreduced matrix has",
     "a well defined set of pairwise different real eigenvalues, the corresponding",
     "real eigenvectors are pairwise orthogonal.",
     "The spectrum may be computed either completely or partially by specifying",
     "either an interval (VL,VU] or a range of indices IL:IU for the desired",
     "eigenvalues.",
     "Depending on the number of desired eigenvalues, these are computed either",
     "by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are",
     "computed by the use of various suitable L D L^T factorizations near clusters",
     "of close eigenvalues (referred to as RRRs, Relatively Robust",
     "Representations). An informal sketch of the algorithm follows.",
     "For each unreduced block (submatrix) of T,",
     "   (a) Compute T - sigma I  = L D L^T, so that L and D",
     "       define all the wanted eigenvalues to high relative accuracy.",
     "       This means that small relative changes in the entries of D and L",
     "       cause only small relative changes in the eigenvalues and",
     "       eigenvectors. The standard (unfactored) representation of the",
     "       tridiagonal matrix T does not have this property in general.",
     "   (b) Compute the eigenvalues to suitable accuracy.",
     "       If the eigenvectors are desired, the algorithm attains full",
     "       accuracy of the computed eigenvalues only right before",
     "       the corresponding vectors have to be computed, see steps c) and d).",
     "   (c) For each cluster of close eigenvalues, select a new",
     "       shift close to the cluster, find a new factorization, and refine",
     "       the shifted eigenvalues to suitable accuracy.",
     "   (d) For each eigenvalue with a large enough relative separation compute",
     "       the corresponding eigenvector by forming a rank revealing twisted",
     "       factorization. Go back to (c) for any clusters that remain.",
     "For more details, see:",
     "- Inderjit S. Dhillon and Beresford N. Parlett: \"Multiple representations",
     "  to compute orthogonal eigenvectors of symmetric tridiagonal matrices,\"",
     "  Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.",
     "- Inderjit Dhillon and Beresford Parlett: \"Orthogonal Eigenvectors and",
     "  Relative Gaps,\" SIAM Journal on Matrix Analysis and Applications, Vol. 25,",
     "  2004.  Also LAPACK Working Note 154.",
     "- Inderjit Dhillon: \"A new O(n^2) algorithm for the symmetric",
     "  tridiagonal eigenvalue/eigenvector problem\",",
     "  Computer Science Division Technical Report No. UCB/CSD-97-971,",
     "  UC Berkeley, May 1997.",
     "Further Details",
     "1.CSTEMR works only on machines which follow IEEE-754",
     "floating-point standard in their handling of infinities and NaNs.",
     "This permits the use of efficient inner loops avoiding a check for",
     "zero divisors.",
     "2. LAPACK routines can be used to reduce a complex Hermitean matrix to",
     "real symmetric tridiagonal form.",
     "(Any complex Hermitean tridiagonal matrix has real values on its diagonal",
     "and potentially complex numbers on its off-diagonals. By applying a",
     "similarity transform with an appropriate diagonal matrix",
     "diag(1,e^{i \\phy_1}, ... , e^{i \\phy_{n-1}}), the complex Hermitean",
     "matrix can be transformed into a real symmetric matrix and complex",
     "arithmetic can be entirely avoided.)",
     "While the eigenvectors of the real symmetric tridiagonal matrix are real,",
     "the eigenvectors of original complex Hermitean matrix have complex entries",
     "in general.",
     "Since LAPACK drivers overwrite the matrix data with the eigenvectors,",
     "CSTEMR accepts complex workspace to facilitate interoperability",
     "with CUNMTR or CUPMTR."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the N diagonal elements of the tridiagonal matrix",
       "         T. On exit, D is overwritten."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N)",
       "         On entry, the (N-1) subdiagonal elements of the tridiagonal",
       "         matrix T in elements 1 to N-1 of E. E(N) need not be set on",
       "         input, but is used internally as workspace.",
       "         On exit, E is overwritten."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         The first M elements contain the selected eigenvalues in",
       "         ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, max(1,M) )",
       "         If JOBZ = 'V', and if INFO = 0, then the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix T",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and can be computed with a workspace",
       "         query by setting NZC = -1, see below."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', then LDZ >= max(1,N)."],
     "NZC"=>
      ["[in]",
       "         NZC is INTEGER",
       "         The number of eigenvectors to be held in the array Z.",
       "         If RANGE = 'A', then NZC >= max(1,N).",
       "         If RANGE = 'V', then NZC >= the number of eigenvalues in (VL,VU].",
       "         If RANGE = 'I', then NZC >= IU-IL+1.",
       "         If NZC = -1, then a workspace query is assumed; the",
       "         routine calculates the number of columns of the array Z that",
       "         are needed to hold the eigenvectors.",
       "         This value is returned as the first entry of the Z array, and",
       "         no error message related to NZC is issued by XERBLA."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER ARRAY, dimension ( 2*max(1,M) )",
       "         The support of the eigenvectors in Z, i.e., the indices",
       "         indicating the nonzero elements in Z. The i-th computed eigenvector",
       "         is nonzero only in elements ISUPPZ( 2*i-1 ) through",
       "         ISUPPZ( 2*i ). This is relevant in the case when the matrix",
       "         is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0."],
     "TRYRAC"=>
      ["[in,out]",
       "         TRYRAC is LOGICAL",
       "         If TRYRAC.EQ..TRUE., indicates that the code should check whether",
       "         the tridiagonal matrix defines its eigenvalues to high relative",
       "         accuracy.  If so, the code uses relative-accuracy preserving",
       "         algorithms that might be (a bit) slower depending on the matrix.",
       "         If the matrix does not define its eigenvalues to high relative",
       "         accuracy, the code can uses possibly faster algorithms.",
       "         If TRYRAC.EQ..FALSE., the code is not required to guarantee",
       "         relatively accurate eigenvalues and can use the fastest possible",
       "         techniques.",
       "         On exit, a .TRUE. TRYRAC will be set to .FALSE. if the matrix",
       "         does not define its eigenvalues to high relative accuracy."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (LWORK)",
       "         On exit, if INFO = 0, WORK(1) returns the optimal",
       "         (and minimal) LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,18*N)",
       "         if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (LIWORK)",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.  LIWORK >= max(1,10*N)",
       "         if the eigenvectors are desired, and LIWORK >= max(1,8*N)",
       "         if only the eigenvalues are to be computed.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, INFO",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = 1X, internal error in SLARRE,",
       "               if INFO = 2X, internal error in CLARRV.",
       "               Here, the digit X = ABS( IINFO ) < 10, where IINFO is",
       "               the nonzero error code returned by SLARRE or",
       "               CLARRV, respectively."]}},
 "zsytri_rook"=>
  {"summary"=>
    ["ZSYTRI_ROOK computes the inverse of a complex symmetric",
     "matrix A using the factorization A = U*D*U**T or A = L*D*L**T",
     "computed by ZSYTRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the block diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by ZSYTRF_ROOK.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSYTRF_ROOK."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "zla_geamv"=>
  {"summary"=>
    ["ZLA_GEAMV  performs one of the matrix-vector operations",
     "        y := alpha*abs(A)*abs(x) + beta*abs(y),",
     "   or   y := alpha*abs(A)**T*abs(x) + beta*abs(y),",
     "where alpha and beta are scalars, x and y are vectors and A is an",
     "m by n matrix.",
     "This function is primarily used in calculating error bounds.",
     "To protect against underflow during evaluation, components in",
     "the resulting vector are perturbed away from zero by (N+1)",
     "times the underflow threshold.  To prevent unnecessarily large",
     "errors for block-structure embedded in general matrices,",
     "\"symbolically\" zero components are not perturbed.  A zero",
     "entry is considered \"symbolic\" if all multiplications involved",
     "in computing that entry have at least one zero multiplicand."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is INTEGER",
       "          On entry, TRANS specifies the operation to be performed as",
       "          follows:",
       "            BLAS_NO_TRANS      y := alpha*abs(A)*abs(x) + beta*abs(y)",
       "            BLAS_TRANS         y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "            BLAS_CONJ_TRANS    y := alpha*abs(A**T)*abs(x) + beta*abs(y)",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of the matrix A.",
       "          M must be at least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of the matrix A.",
       "          N must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array of DIMENSION ( LDA, n )",
       "          Before entry, the leading m by n part of the array A must",
       "          contain the matrix of coefficients.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in the calling (sub) program. LDA must be at least",
       "          max( 1, m ).",
       "          Unchanged on exit."],
     "X"=>
      ["[in]",
       "         X is COMPLEX*16 array of DIMENSION at least",
       "          ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.",
       "          Before entry, the incremented array X must contain the",
       "          vector x.",
       "          Unchanged on exit."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "          On entry, INCX specifies the increment for the elements of",
       "          X. INCX must not be zero.",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION",
       "          On entry, BETA specifies the scalar beta. When BETA is",
       "          supplied as zero then Y need not be set on input.",
       "          Unchanged on exit."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension",
       "          ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'",
       "          and at least",
       "          ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.",
       "          Before entry with BETA non-zero, the incremented array Y",
       "          must contain the vector y. On exit, Y is overwritten by the",
       "          updated vector y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "          On entry, INCY specifies the increment for the elements of",
       "          Y. INCY must not be zero.",
       "          Unchanged on exit.",
       " Level 2 Blas routine."]}},
 "zsytrs_aa"=>
  {"summary"=>
    ["ZSYTRS_AA solves a system of linear equations A*X = B with a complex",
     "symmetric matrix A using the factorization A = U*T*U**T or",
     "A = L*T*L**T computed by ZSYTRF_AA."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*T*U**T;",
       "         = 'L':  Lower triangular, form is A = L*T*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         Details of factors computed by ZSYTRF_AA."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges as computed by ZSYTRF_AA."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[in]", "         WORK is DOUBLE array, dimension (MAX(1,LWORK))"],
     "LWORK"=>["[in]", "         LWORK is INTEGER, LWORK >= MAX(1,3*N-2)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slaed3"=>
  {"summary"=>
    ["SLAED3 finds the roots of the secular equation, as defined by the",
     "values in D, W, and RHO, between 1 and K.  It makes the",
     "appropriate calls to SLAED4 and then updates the eigenvectors by",
     "multiplying the matrix of eigenvectors of the pair of eigensystems",
     "being combined by the matrix of eigenvectors of the K-by-K system",
     "which is solved here.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of terms in the rational function to be solved by",
       "         SLAED4.  K >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows and columns in the Q matrix.",
       "         N >= K (deflation may result in N>K)."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         The location of the last eigenvalue in the leading submatrix.",
       "         min(1,N) <= N1 <= N/2."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         D(I) contains the updated eigenvalues for",
       "         1 <= I <= K."],
     "Q"=>
      ["[out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "         Initially the first K columns are used as workspace.",
       "         On output the columns 1 to K contain",
       "         the updated eigenvectors."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= max(1,N)."],
     "RHO"=>
      ["[in]",
       "         RHO is REAL",
       "         The value of the parameter in the rank one update equation.",
       "         RHO >= 0 required."],
     "DLAMDA"=>
      ["[in,out]",
       "         DLAMDA is REAL array, dimension (K)",
       "         The first K elements of this array contain the old roots",
       "         of the deflated updating problem.  These are the poles",
       "         of the secular equation. May be changed on output by",
       "         having lowest order bit set to zero on Cray X-MP, Cray Y-MP,",
       "         Cray-2, or Cray C-90, as described above."],
     "Q2"=>
      ["[in]",
       "         Q2 is REAL array, dimension (LDQ2, N)",
       "         The first K columns of this matrix contain the non-deflated",
       "         eigenvectors for the split problem."],
     "INDX"=>
      ["[in]",
       "         INDX is INTEGER array, dimension (N)",
       "         The permutation used to arrange the columns of the deflated",
       "         Q matrix into three groups (see SLAED2).",
       "         The rows of the eigenvectors found by SLAED4 must be likewise",
       "         permuted before the matrix multiply can take place."],
     "CTOT"=>
      ["[in]",
       "         CTOT is INTEGER array, dimension (4)",
       "         A count of the total number of the various types of columns",
       "         in Q, as described in INDX.  The fourth column type is any",
       "         column which has been deflated."],
     "W"=>
      ["[in,out]",
       "         W is REAL array, dimension (K)",
       "         The first K elements of this array contain the components",
       "         of the deflation-adjusted updating vector. Destroyed on",
       "         output."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (N1 + 1)*K",
       "         Will contain the eigenvectors of the repaired matrix which",
       "         will be multiplied by the previously accumulated eigenvectors",
       "         to update the system."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, an eigenvalue did not converge"]}},
 "dsytrs_rook"=>
  {"summary"=>
    ["DSYTRS_ROOK solves a system of linear equations A*X = B with",
     "a real symmetric matrix A using the factorization A = U*D*U**T or",
     "A = L*D*L**T computed by DSYTRF_ROOK."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by DSYTRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by DSYTRF_ROOK."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlalsd"=>
  {"summary"=>
    ["DLALSD uses the singular value decomposition of A to solve the least",
     "squares problem of finding X to minimize the Euclidean norm of each",
     "column of A*X-B, where A is N-by-N upper bidiagonal, and X and B",
     "are N-by-NRHS. The solution X overwrites B.",
     "The singular values of A smaller than RCOND times the largest",
     "singular value are treated as zero in solving the least squares",
     "problem; in this case a minimum norm solution is returned.",
     "The actual singular values are returned in D in ascending order.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "        = 'U': D and E define an upper bidiagonal matrix.",
       "        = 'L': D and E define a  lower bidiagonal matrix."],
     "SMLSIZ"=>
      ["[in]",
       "         SMLSIZ is INTEGER",
       "        The maximum size of the subproblems at the bottom of the",
       "        computation tree."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the  bidiagonal matrix.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "        The number of columns of B. NRHS must be at least 1."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        On entry D contains the main diagonal of the bidiagonal",
       "        matrix. On exit, if INFO = 0, D contains its singular values."],
     "E"=>
      ["[in,out]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "        Contains the super-diagonal entries of the bidiagonal matrix.",
       "        On exit, E has been destroyed."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "        On input, B contains the right hand sides of the least",
       "        squares problem. On output, B contains the solution X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "        The leading dimension of B in the calling subprogram.",
       "        LDB must be at least max(1,N)."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "        The singular values of A less than or equal to RCOND times",
       "        the largest singular value are treated as zero in solving",
       "        the least squares problem. If RCOND is negative,",
       "        machine precision is used instead.",
       "        For example, if diag(S)*X=B were the least squares problem,",
       "        where diag(S) is a diagonal matrix of singular values, the",
       "        solution would be X(i) = B(i) / S(i) if S(i) is greater than",
       "        RCOND*max(S), and X(i) = 0 if S(i) is less than or equal to",
       "        RCOND*max(S)."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "        The number of singular values of A greater than RCOND times",
       "        the largest singular value."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension at least",
       "        (9*N + 2*N*SMLSIZ + 8*N*NLVL + N*NRHS + (SMLSIZ+1)**2),",
       "        where NLVL = max(0, INT(log_2 (N/(SMLSIZ+1))) + 1)."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension at least",
       "        (3*N*NLVL + 11*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "        = 0:  successful exit.",
       "        < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "        > 0:  The algorithm failed to compute a singular value while",
       "              working on the submatrix lying in rows and columns",
       "              INFO/(N+1) through MOD(INFO,N+1)."]}},
 "dlabad"=>
  {"summary"=>
    ["DLABAD takes as input the values computed by DLAMCH for underflow and",
     "overflow, and returns the square root of each of these values if the",
     "log of LARGE is sufficiently large.  This subroutine is intended to",
     "identify machines with a large exponent range, such as the Crays, and",
     "redefine the underflow and overflow limits to be the square roots of",
     "the values computed by DLAMCH.  This subroutine is needed because",
     "DLAMCH does not compensate for poor arithmetic in the upper half of",
     "the exponent range, as is found on a Cray."],
   "param"=>
    {"SMALL"=>
      ["[in,out]",
       "         SMALL is DOUBLE PRECISION",
       "         On entry, the underflow threshold as computed by DLAMCH.",
       "         On exit, if LOG10(LARGE) is sufficiently large, the square",
       "         root of SMALL, otherwise unchanged."],
     "LARGE"=>
      ["[in,out]",
       "         LARGE is DOUBLE PRECISION",
       "         On entry, the overflow threshold as computed by DLAMCH.",
       "         On exit, if LOG10(LARGE) is sufficiently large, the square",
       "         root of LARGE, otherwise unchanged."]}},
 "zlahef"=>
  {"summary"=>
    ["ZLAHEF computes a partial factorization of a complex Hermitian",
     "matrix A using the Bunch-Kaufman diagonal pivoting method. The",
     "partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I      0     )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**H U22**H )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**H L21**H )  if UPLO = 'L'",
     "      ( L21  I ) (  0  A22 ) (  0      I     )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "Note that U**H denotes the conjugate transpose of U.",
     "ZLAHEF is an auxiliary routine called by ZHETRF. It uses blocked code",
     "(calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or",
     "A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, A contains details of the partial factorization."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            Only the last KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            Only the first KB elements of IPIV are set.",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "W"=>["[out]", "         W is COMPLEX*16 array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular."]}},
 "zlaset"=>
  {"summary"=>
    ["ZLASET initializes a 2-D array A to BETA on the diagonal and",
     "ALPHA on the offdiagonals."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies the part of the matrix A to be set.",
       "         = 'U':      Upper triangular part is set. The lower triangle",
       "                     is unchanged.",
       "         = 'L':      Lower triangular part is set. The upper triangle",
       "                     is unchanged.",
       "         Otherwise:  All of the matrix A is set."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         On entry, M specifies the number of rows of A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         On entry, N specifies the number of columns of A."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX*16",
       "         All the offdiagonal array elements are set to ALPHA."],
     "BETA"=>
      ["[in]",
       "         BETA is COMPLEX*16",
       "         All the diagonal array elements are set to BETA."],
     "A"=>
      ["[out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the m by n matrix A.",
       "         On exit, A(i,j) = ALPHA, 1 <= i <= m, 1 <= j <= n, i.ne.j;",
       "                  A(i,i) = BETA , 1 <= i <= min(m,n)"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."]}},
 "zlahef_rk"=>
  {"summary"=>
    ["ZLAHEF_RK computes a partial factorization of a complex Hermitian",
     "matrix A using the bounded Bunch-Kaufman (rook) diagonal",
     "pivoting method. The partial factorization has the form:",
     "A  =  ( I  U12 ) ( A11  0  ) (  I       0    )  if UPLO = 'U', or:",
     "      ( 0  U22 ) (  0   D  ) ( U12**H U22**H )",
     "A  =  ( L11  0 ) (  D   0  ) ( L11**H L21**H )  if UPLO = 'L',",
     "      ( L21  I ) (  0  A22 ) (  0       I    )",
     "where the order of D is at most NB. The actual order is returned in",
     "the argument KB, and is either NB or NB-1, or N if N <= NB.",
     "ZLAHEF_RK is an auxiliary routine called by ZHETRF_RK. It uses",
     "blocked code (calling Level 3 BLAS) to update the submatrix",
     "A11 (if UPLO = 'U') or A22 (if UPLO = 'L')."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The maximum number of columns of the matrix A that should be",
       "         factored.  NB should be at least 2 to allow for 2-by-2 pivot",
       "         blocks."],
     "KB"=>
      ["[out]",
       "         KB is INTEGER",
       "         The number of columns of A that were actually factored.",
       "         KB is either NB-1 or NB, or N if N <= NB."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.",
       "           If UPLO = 'U': the leading N-by-N upper triangular part",
       "           of A contains the upper triangular part of the matrix A,",
       "           and the strictly lower triangular part of A is not",
       "           referenced.",
       "           If UPLO = 'L': the leading N-by-N lower triangular part",
       "           of A contains the lower triangular part of the matrix A,",
       "           and the strictly upper triangular part of A is not",
       "           referenced.",
       "         On exit, contains:",
       "           a) ONLY diagonal elements of the Hermitian block diagonal",
       "              matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);",
       "              (superdiagonal (or subdiagonal) elements of D",
       "               are stored on exit in array E), and",
       "           b) If UPLO = 'U': factor U in the superdiagonal part of A.",
       "              If UPLO = 'L': factor L in the subdiagonal part of A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "E"=>
      ["[out]",
       "         E is COMPLEX*16 array, dimension (N)",
       "         On exit, contains the superdiagonal (or subdiagonal)",
       "         elements of the Hermitian block diagonal matrix D",
       "         with 1-by-1 or 2-by-2 diagonal blocks, where",
       "         If UPLO = 'U': E(i) = D(i-1,i), i=2:N, E(1) is set to 0;",
       "         If UPLO = 'L': E(i) = D(i+1,i), i=1:N-1, E(N) is set to 0.",
       "         NOTE: For 1-by-1 diagonal block D(k), where",
       "         1 <= k <= N, the element E(k) is set to 0 in both",
       "         UPLO = 'U' or UPLO = 'L' cases."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         IPIV describes the permutation matrix P in the factorization",
       "         of matrix A as follows. The absolute value of IPIV(k)",
       "         represents the index of row and column that were",
       "         interchanged with the k-th row and column. The value of UPLO",
       "         describes the order in which the interchanges were applied.",
       "         Also, the sign of IPIV represents the block structure of",
       "         the Hermitian block diagonal matrix D with 1-by-1 or 2-by-2",
       "         diagonal blocks which correspond to 1 or 2 interchanges",
       "         at each factorization step.",
       "         If UPLO = 'U',",
       "         ( in factorization order, k decreases from N to 1 ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,N-KB+1:N);",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k-1) < 0 means:",
       "              D(k-1:k,k-1:k) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the matrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k-1) != k-1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,N-KB+1:N).",
       "                 If -IPIV(k-1) = k-1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) <= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output.",
       "         If UPLO = 'L',",
       "         ( in factorization order, k increases from 1 to N ):",
       "           a) A single positive entry IPIV(k) > 0 means:",
       "              D(k,k) is a 1-by-1 diagonal block.",
       "              If IPIV(k) != k, rows and columns k and IPIV(k) were",
       "              interchanged in the submatrix A(1:N,1:KB).",
       "              If IPIV(k) = k, no interchange occurred.",
       "           b) A pair of consecutive negative entries",
       "              IPIV(k) < 0 and IPIV(k+1) < 0 means:",
       "              D(k:k+1,k:k+1) is a 2-by-2 diagonal block.",
       "              (NOTE: negative entries in IPIV appear ONLY in pairs).",
       "              1) If -IPIV(k) != k, rows and columns",
       "                 k and -IPIV(k) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k) = k, no interchange occurred.",
       "              2) If -IPIV(k+1) != k+1, rows and columns",
       "                 k-1 and -IPIV(k-1) were interchanged",
       "                 in the submatrix A(1:N,1:KB).",
       "                 If -IPIV(k+1) = k+1, no interchange occurred.",
       "           c) In both cases a) and b) is always ABS( IPIV(k) ) >= k.",
       "           d) NOTE: Any entry IPIV(k) is always NONZERO on output."],
     "W"=>["[out]", "         W is COMPLEX*16 array, dimension (LDW,NB)"],
     "LDW"=>
      ["[in]",
       "         LDW is INTEGER",
       "         The leading dimension of the array W.  LDW >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: If INFO = -k, the k-th argument had an illegal value",
       "         > 0: If INFO = k, the matrix A is singular, because:",
       "                If UPLO = 'U': column k in the upper",
       "                triangular part of A contains all zeros.",
       "                If UPLO = 'L': column k in the lower",
       "                triangular part of A contains all zeros.",
       "              Therefore D(k,k) is exactly zero, and superdiagonal",
       "              elements of column k of U (or subdiagonal elements of",
       "              column k of L ) are all zeros. The factorization has",
       "              been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if",
       "              it is used to solve a system of equations.",
       "              NOTE: INFO only stores the first occurrence of",
       "              a singularity, any subsequent occurrence of singularity",
       "              is not stored in INFO even though the factorization",
       "              always completes."]}},
 "csytri2x"=>
  {"summary"=>
    ["CSYTRI2X computes the inverse of a real symmetric indefinite matrix",
     "A using the factorization A = U*D*U**T or A = L*D*L**T computed by",
     "CSYTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the NNB diagonal matrix D and the multipliers",
       "         used to obtain the factor U or L as computed by CSYTRF.",
       "         On exit, if INFO = 0, the (symmetric) inverse of the original",
       "         matrix.  If UPLO = 'U', the upper triangular part of the",
       "         inverse is formed and the part of A below the diagonal is not",
       "         referenced; if UPLO = 'L' the lower triangular part of the",
       "         inverse is formed and the part of A above the diagonal is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the NNB structure of D",
       "         as determined by CSYTRF."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX array, dimension (N+NNB+1,NNB+3)"],
     "NB"=>["[in]", "         NB is INTEGER", "         Block size"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its",
       "              inverse could not be computed."]}},
 "dlaed6"=>
  {"summary"=>
    ["DLAED6 computes the positive or negative root (closest to the origin)",
     "of",
     "                 z(1)        z(2)        z(3)",
     "f(x) =   rho + --------- + ---------- + ---------",
     "                d(1)-x      d(2)-x      d(3)-x",
     "It is assumed that",
     "      if ORGATI = .true. the root is between d(2) and d(3);",
     "      otherwise it is between d(1) and d(2)",
     "This routine will be called by DLAED4 when necessary. In most cases,",
     "the root sought is the smallest in magnitude, though it might not be",
     "in some extremely rare situations."],
   "param"=>
    {"KNITER"=>
      ["[in]",
       "         KNITER is INTEGER",
       "              Refer to DLAED4 for its significance."],
     "ORGATI"=>
      ["[in]",
       "         ORGATI is LOGICAL",
       "              If ORGATI is true, the needed root is between d(2) and",
       "              d(3); otherwise it is between d(1) and d(2).  See",
       "              DLAED4 for further details."],
     "RHO"=>
      ["[in]",
       "         RHO is DOUBLE PRECISION",
       "              Refer to the equation f(x) above."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (3)",
       "              D satisfies d(1) < d(2) < d(3)."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension (3)",
       "              Each of the elements in z must be positive."],
     "FINIT"=>
      ["[in]",
       "         FINIT is DOUBLE PRECISION",
       "              The value of f at 0. It is more accurate than the one",
       "              evaluated inside this routine (if someone wants to do",
       "              so)."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION",
       "              The root of the equation f(x)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "              = 0: successful exit",
       "              > 0: if INFO = 1, failure to converge"]}},
 "cggbak"=>
  {"summary"=>
    ["CGGBAK forms the right or left eigenvectors of a complex generalized",
     "eigenvalue problem A*x = lambda*B*x, by backward transformation on",
     "the computed eigenvectors of the balanced pair of matrices output by",
     "CGGBAL."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is CHARACTER*1",
       "         Specifies the type of backward transformation required:",
       "         = 'N':  do nothing, return immediately;",
       "         = 'P':  do backward transformation for permutation only;",
       "         = 'S':  do backward transformation for scaling only;",
       "         = 'B':  do backward transformations for both permutation and",
       "                 scaling.",
       "         JOB must be the same as the argument JOB supplied to CGGBAL."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'R':  V contains right eigenvectors;",
       "         = 'L':  V contains left eigenvectors."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows of the matrix V.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         The integers ILO and IHI determined by CGGBAL.",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "LSCALE"=>
      ["[in]",
       "         LSCALE is REAL array, dimension (N)",
       "         Details of the permutations and/or scaling factors applied",
       "         to the left side of A and B, as returned by CGGBAL."],
     "RSCALE"=>
      ["[in]",
       "         RSCALE is REAL array, dimension (N)",
       "         Details of the permutations and/or scaling factors applied",
       "         to the right side of A and B, as returned by CGGBAL."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of columns of the matrix V.  M >= 0."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX array, dimension (LDV,M)",
       "         On entry, the matrix of right or left eigenvectors to be",
       "         transformed, as returned by CTGEVC.",
       "         On exit, V is overwritten by the transformed eigenvectors."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the matrix V. LDV >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slar1v"=>
  {"summary"=>
    ["SLAR1V computes the (scaled) r-th column of the inverse of",
     "the sumbmatrix in rows B1 through BN of the tridiagonal matrix",
     "L D L**T - sigma I. When sigma is close to an eigenvalue, the",
     "computed vector is an accurate eigenvector. Usually, r corresponds",
     "to the index where the eigenvector is largest in magnitude.",
     "The following steps accomplish this computation :",
     "(a) Stationary qd transform,  L D L**T - sigma I = L(+) D(+) L(+)**T,",
     "(b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,",
     "(c) Computation of the diagonal elements of the inverse of",
     "    L D L**T - sigma I by combining the above transforms, and choosing",
     "    r as the index where the diagonal of the inverse is (one of the)",
     "    largest in magnitude.",
     "(d) Computation of the (scaled) r-th column of the inverse using the",
     "    twisted factorization obtained by combining the top part of the",
     "    the stationary and the bottom part of the progressive transform."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix L D L**T."],
     "B1"=>
      ["[in]",
       "         B1 is INTEGER",
       "          First index of the submatrix of L D L**T."],
     "BN"=>
      ["[in]",
       "         BN is INTEGER",
       "          Last index of the submatrix of L D L**T."],
     "LAMBDA"=>
      ["[in]",
       "         LAMBDA is REAL",
       "          The shift. In order to compute an accurate eigenvector,",
       "          LAMBDA should be a good approximation to an eigenvalue",
       "          of L D L**T."],
     "L"=>
      ["[in]",
       "         L is REAL array, dimension (N-1)",
       "          The (n-1) subdiagonal elements of the unit bidiagonal matrix",
       "          L, in elements 1 to N-1."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (N)",
       "          The n diagonal elements of the diagonal matrix D."],
     "LD"=>
      ["[in]",
       "         LD is REAL array, dimension (N-1)",
       "          The n-1 elements L(i)*D(i)."],
     "LLD"=>
      ["[in]",
       "         LLD is REAL array, dimension (N-1)",
       "          The n-1 elements L(i)*L(i)*D(i)."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is REAL",
       "          The minimum pivot in the Sturm sequence."],
     "GAPTOL"=>
      ["[in]",
       "         GAPTOL is REAL",
       "          Tolerance that indicates when eigenvector entries are negligible",
       "          w.r.t. their contribution to the residual."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (N)",
       "          On input, all entries of Z must be set to 0.",
       "          On output, Z contains the (scaled) r-th column of the",
       "          inverse. The scaling is such that Z(R) equals 1."],
     "WANTNC"=>
      ["[in]",
       "         WANTNC is LOGICAL",
       "          Specifies whether NEGCNT has to be computed."],
     "NEGCNT"=>
      ["[out]",
       "         NEGCNT is INTEGER",
       "          If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin",
       "          in the  matrix factorization L D L**T, and NEGCNT = -1 otherwise."],
     "ZTZ"=>
      ["[out]",
       "         ZTZ is REAL",
       "          The square of the 2-norm of Z."],
     "MINGMA"=>
      ["[out]",
       "         MINGMA is REAL",
       "          The reciprocal of the largest (in magnitude) diagonal",
       "          element of the inverse of L D L**T - sigma I."],
     "R"=>
      ["[in,out]",
       "         R is INTEGER",
       "          The twist index for the twisted factorization used to",
       "          compute Z.",
       "          On input, 0 <= R <= N. If R is input as 0, R is set to",
       "          the index where (L D L**T - sigma I)^{-1} is largest",
       "          in magnitude. If 1 <= R <= N, R is unchanged.",
       "          On output, R contains the twist index used to compute Z.",
       "          Ideally, R designates the position of the maximum entry in the",
       "          eigenvector."],
     "ISUPPZ"=>
      ["[out]",
       "         ISUPPZ is INTEGER array, dimension (2)",
       "          The support of the vector in Z, i.e., the vector Z is",
       "          nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 )."],
     "NRMINV"=>
      ["[out]", "         NRMINV is REAL", "          NRMINV = 1/SQRT( ZTZ )"],
     "RESID"=>
      ["[out]",
       "         RESID is REAL",
       "          The residual of the FP vector.",
       "          RESID = ABS( MINGMA )/SQRT( ZTZ )"],
     "RQCORR"=>
      ["[out]",
       "         RQCORR is REAL",
       "          The Rayleigh Quotient correction to LAMBDA.",
       "          RQCORR = MINGMA*TMP"],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (4*N)"]}},
 "zhesv_aa"=>
  {"summary"=>
    ["ZHESV_AA computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian matrix and X and B are N-by-NRHS",
     "matrices.",
     "Aasen's algorithm is used to factor A as",
     "   A = U * T * U**H,  if UPLO = 'U', or",
     "   A = L * T * L**H,  if UPLO = 'L',",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, and T is Hermitian and tridiagonal. The factored form",
     "of A is then used to solve the system of equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the tridiagonal matrix T and the",
       "         multipliers used to obtain the factor U or L from the",
       "         factorization A = U*T*U**H or A = L*T*L**H as computed by",
       "         ZHETRF_AA."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         On exit, it contains the details of the interchanges, i.e.,",
       "         the row and column k of A were interchanged with the",
       "         row and column IPIV(k)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of WORK.  LWORK >= MAX(1,2*N,3*N-2), and for best ",
       "         performance LWORK >= max(1,N*NB), where NB is the optimal",
       "         blocksize for ZHETRF.",
       "         for LWORK < N, TRS will be done with Level BLAS 2",
       "         for LWORK >= N, TRS will be done with Level BLAS 3",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value",
       "         > 0: if INFO = i, D(i,i) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, so the solution could not be computed."]}},
 "ssbtrd"=>
  {"summary"=>
    ["SSBTRD reduces a real symmetric band matrix A to symmetric",
     "tridiagonal form T by an orthogonal similarity transformation:",
     "Q**T * A * Q = T."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'N':  do not form Q;",
       "         = 'V':  form Q;",
       "         = 'U':  update a matrix X, by forming X*Q."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, the diagonal elements of AB are overwritten by the",
       "         diagonal elements of the tridiagonal matrix T; if KD > 0, the",
       "         elements on the first superdiagonal (if UPLO = 'U') or the",
       "         first subdiagonal (if UPLO = 'L') are overwritten by the",
       "         off-diagonal elements of T; the rest of AB is overwritten by",
       "         values generated during the reduction."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = T(i,i+1) if UPLO = 'U'; E(i) = T(i+1,i) if UPLO = 'L'."],
     "Q"=>
      ["[in,out]",
       "         Q is REAL array, dimension (LDQ,N)",
       "         On entry, if VECT = 'U', then Q must contain an N-by-N",
       "         matrix X; if VECT = 'N' or 'V', then Q need not be set.",
       "         On exit:",
       "         if VECT = 'V', Q contains the N-by-N orthogonal matrix Q;",
       "         if VECT = 'U', Q contains the product X*Q;",
       "         if VECT = 'N', the array Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.",
       "         LDQ >= 1, and LDQ >= N if VECT = 'V' or 'U'."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sstedc"=>
  {"summary"=>
    ["SSTEDC computes all eigenvalues and, optionally, eigenvectors of a",
     "symmetric tridiagonal matrix using the divide and conquer method.",
     "The eigenvectors of a full or band real symmetric matrix can also be",
     "found if SSYTRD or SSPTRD or SSBTRD has been used to reduce this",
     "matrix to tridiagonal form.",
     "This code makes very mild assumptions about floating point",
     "arithmetic. It will work on machines with a guard digit in",
     "add/subtract, or on those binary machines without guard digits",
     "which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2.",
     "It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none.  See SLAED3 for details."],
   "param"=>
    {"COMPZ"=>
      ["[in]",
       "         COMPZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only.",
       "         = 'I':  Compute eigenvectors of tridiagonal matrix also.",
       "         = 'V':  Compute eigenvectors of original dense symmetric",
       "                 matrix also.  On entry, Z contains the orthogonal",
       "                 matrix used to reduce the original matrix to",
       "                 tridiagonal form."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the diagonal elements of the tridiagonal matrix.",
       "         On exit, if INFO = 0, the eigenvalues in ascending order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the subdiagonal elements of the tridiagonal matrix.",
       "         On exit, E has been destroyed."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ,N)",
       "         On entry, if COMPZ = 'V', then Z contains the orthogonal",
       "         matrix used in the reduction to tridiagonal form.",
       "         On exit, if INFO = 0, then if COMPZ = 'V', Z contains the",
       "         orthonormal eigenvectors of the original symmetric matrix,",
       "         and if COMPZ = 'I', Z contains the orthonormal eigenvectors",
       "         of the symmetric tridiagonal matrix.",
       "         If  COMPZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1.",
       "         If eigenvectors are desired, then LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If COMPZ = 'N' or N <= 1 then LWORK must be at least 1.",
       "         If COMPZ = 'V' and N > 1 then LWORK must be at least",
       "                        ( 1 + 3*N + 2*N*lg N + 4*N**2 ),",
       "                        where lg( N ) = smallest integer k such",
       "                        that 2**k >= N.",
       "         If COMPZ = 'I' and N > 1 then LWORK must be at least",
       "                        ( 1 + 4*N + N**2 ).",
       "         Note that for COMPZ = 'I' or 'V', then if N is less than or",
       "         equal to the minimum divide size, usually 25, then LWORK need",
       "         only be max(1,2*(N-1)).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of the array IWORK.",
       "         If COMPZ = 'N' or N <= 1 then LIWORK must be at least 1.",
       "         If COMPZ = 'V' and N > 1 then LIWORK must be at least",
       "                        ( 6 + 6*N + 5*N*lg N ).",
       "         If COMPZ = 'I' and N > 1 then LIWORK must be at least",
       "                        ( 3 + 5*N ).",
       "         Note that for COMPZ = 'I' or 'V', then if N is less than or",
       "         equal to the minimum divide size, usually 25, then LIWORK",
       "         need only be 1.",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal size of the IWORK array,",
       "         returns this value as the first entry of the IWORK array, and",
       "         no error message related to LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  The algorithm failed to compute an eigenvalue while",
       "               working on the submatrix lying in rows and columns",
       "               INFO/(N+1) through mod(INFO,N+1)."]}},
 "dstebz"=>
  {"summary"=>
    ["DSTEBZ computes the eigenvalues of a symmetric tridiagonal",
     "matrix T.  The user may ask for all eigenvalues, all eigenvalues",
     "in the half-open interval (VL, VU], or the IL-th through IU-th",
     "eigenvalues.",
     "To avoid overflow, the matrix must be scaled so that its",
     "largest element is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest",
     "accuracy, it should not be much smaller than that.",
     "See W. Kahan \"Accurate Eigenvalues of a Symmetric Tridiagonal",
     "Matrix\", Report CS41, Computer Science Dept., Stanford",
     "University, July 21, 1966."],
   "param"=>
    {"RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': (\"All\")   all eigenvalues will be found.",
       "         = 'V': (\"Value\") all eigenvalues in the half-open interval",
       "                          (VL, VU] will be found.",
       "         = 'I': (\"Index\") the IL-th through IU-th eigenvalues (of the",
       "                          entire matrix) will be found."],
     "ORDER"=>
      ["[in]",
       "         ORDER is CHARACTER*1",
       "         = 'B': (\"By Block\") the eigenvalues will be grouped by",
       "                             split-off block (see IBLOCK, ISPLIT) and",
       "                             ordered from smallest to largest within",
       "                             the block.",
       "         = 'E': (\"Entire matrix\")",
       "                             the eigenvalues for the entire matrix",
       "                             will be ordered from smallest to",
       "                             largest."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the tridiagonal matrix T.  N >= 0."],
     "VL"=>
      ["[in]",
       "         VL is DOUBLE PRECISION",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues.  Eigenvalues less than or equal",
       "         to VL, or greater than VU, will not be returned.  VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is DOUBLE PRECISION",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues.  Eigenvalues less than or equal",
       "         to VL, or greater than VU, will not be returned.  VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is DOUBLE PRECISION",
       "         The absolute tolerance for the eigenvalues.  An eigenvalue",
       "         (or cluster) is considered to be located if it has been",
       "         determined to lie in an interval whose width is ABSTOL or",
       "         less.  If ABSTOL is less than or equal to zero, then ULP*|T|",
       "         will be used, where |T| means the 1-norm of T.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the tridiagonal matrix T."],
     "E"=>
      ["[in]",
       "         E is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) off-diagonal elements of the tridiagonal matrix T."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The actual number of eigenvalues found. 0 <= M <= N.",
       "         (See also the description of INFO=2,3.)"],
     "NSPLIT"=>
      ["[out]",
       "         NSPLIT is INTEGER",
       "         The number of diagonal blocks in the matrix T.",
       "         1 <= NSPLIT <= N."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         On exit, the first M elements of W will contain the",
       "         eigenvalues.  (DSTEBZ may use the remaining N-M elements as",
       "         workspace.)"],
     "IBLOCK"=>
      ["[out]",
       "         IBLOCK is INTEGER array, dimension (N)",
       "         At each row/column j where E(j) is zero or small, the",
       "         matrix T is considered to split into a block diagonal",
       "         matrix.  On exit, if INFO = 0, IBLOCK(i) specifies to which",
       "         block (from 1 to the number of blocks) the eigenvalue W(i)",
       "         belongs.  (DSTEBZ may use the remaining N-M elements as",
       "         workspace.)"],
     "ISPLIT"=>
      ["[out]",
       "         ISPLIT is INTEGER array, dimension (N)",
       "         The splitting points, at which T breaks up into submatrices.",
       "         The first submatrix consists of rows/columns 1 to ISPLIT(1),",
       "         the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),",
       "         etc., and the NSPLIT-th consists of rows/columns",
       "         ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.",
       "         (Only the first NSPLIT elements will actually be used, but",
       "         since the user cannot know a priori what value NSPLIT will",
       "         have, N words must be reserved for ISPLIT.)"],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  some or all of the eigenvalues failed to converge or",
       "               were not computed:",
       "               =1 or 3: Bisection failed to converge for some",
       "                       eigenvalues; these eigenvalues are flagged by a",
       "                       negative block number.  The effect is that the",
       "                       eigenvalues may not be as accurate as the",
       "                       absolute and relative tolerances.  This is",
       "                       generally caused by unexpectedly inaccurate",
       "                       arithmetic.",
       "               =2 or 3: RANGE='I' only: Not all of the eigenvalues",
       "                       IL:IU were found.",
       "                       Effect: M < IU+1-IL",
       "                       Cause:  non-monotonic arithmetic, causing the",
       "                               Sturm sequence to be non-monotonic.",
       "                       Cure:   recalculate, using RANGE='A', and pick",
       "                               out eigenvalues IL:IU.  In some cases,",
       "                               increasing the PARAMETER \"FUDGE\" may",
       "                               make things work.",
       "               = 4:    RANGE='I', and the Gershgorin interval",
       "                       initially used was too small.  No eigenvalues",
       "                       were computed.",
       "                       Probable cause: your machine has sloppy",
       "                                       floating-point arithmetic.",
       "                       Cure: Increase the PARAMETER \"FUDGE\",",
       "                             recompile, and try again."]}},
 "slaein"=>
  {"summary"=>
    ["SLAEIN uses inverse iteration to find a right or left eigenvector",
     "corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg",
     "matrix H."],
   "param"=>
    {"RIGHTV"=>
      ["[in]",
       "         RIGHTV is LOGICAL",
       "         = .TRUE. : compute right eigenvector;",
       "         = .FALSE.: compute left eigenvector."],
     "NOINIT"=>
      ["[in]",
       "         NOINIT is LOGICAL",
       "         = .TRUE. : no initial vector supplied in (VR,VI).",
       "         = .FALSE.: initial vector supplied in (VR,VI)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "H"=>
      ["[in]",
       "         H is REAL array, dimension (LDH,N)",
       "         The upper Hessenberg matrix H."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H.  LDH >= max(1,N)."],
     "WR"=>["[in]", "         WR is REAL"],
     "WI"=>
      ["[in]",
       "         WI is REAL",
       "         The real and imaginary parts of the eigenvalue of H whose",
       "         corresponding right or left eigenvector is to be computed."],
     "VR"=>["[in,out]", "         VR is REAL array, dimension (N)"],
     "VI"=>
      ["[in,out]",
       "         VI is REAL array, dimension (N)",
       "         On entry, if NOINIT = .FALSE. and WI = 0.0, VR must contain",
       "         a real starting vector for inverse iteration using the real",
       "         eigenvalue WR; if NOINIT = .FALSE. and WI.ne.0.0, VR and VI",
       "         must contain the real and imaginary parts of a complex",
       "         starting vector for inverse iteration using the complex",
       "         eigenvalue (WR,WI); otherwise VR and VI need not be set.",
       "         On exit, if WI = 0.0 (real eigenvalue), VR contains the",
       "         computed real eigenvector; if WI.ne.0.0 (complex eigenvalue),",
       "         VR and VI contain the real and imaginary parts of the",
       "         computed complex eigenvector. The eigenvector is normalized",
       "         so that the component of largest magnitude has magnitude 1;",
       "         here the magnitude of a complex number (x,y) is taken to be",
       "         |x| + |y|.",
       "         VI is not referenced if WI = 0.0."],
     "B"=>["[out]", "         B is REAL array, dimension (LDB,N)"],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= N+1."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (N)"],
     "EPS3"=>
      ["[in]",
       "         EPS3 is REAL",
       "         A small machine-dependent value which is used to perturb",
       "         close eigenvalues, and to replace zero pivots."],
     "SMLNUM"=>
      ["[in]",
       "         SMLNUM is REAL",
       "         A machine-dependent value close to the underflow threshold."],
     "BIGNUM"=>
      ["[in]",
       "         BIGNUM is REAL",
       "         A machine-dependent value close to the overflow threshold."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         = 1:  inverse iteration did not converge; VR is set to the",
       "               last iterate, and so is VI if WI.ne.0.0."]}},
 "dla_gbrfsx_extended"=>
  {"summary"=>
    ["DLA_GBRFSX_EXTENDED improves the computed solution to a system of",
     "linear equations by performing extra-precise iterative refinement",
     "and provides error bounds and backward error estimates for the solution.",
     "This subroutine is called by DGBRFSX to perform iterative refinement.",
     "In addition to normwise error bound, the code provides maximum",
     "componentwise error bound if possible. See comments for ERR_BNDS_NORM",
     "and ERR_BNDS_COMP for details of the error bounds. Note that this",
     "subroutine is only resonsible for setting the second fields of",
     "ERR_BNDS_NORM and ERR_BNDS_COMP."],
   "param"=>
    {"PREC_TYPE"=>
      ["[in]",
       "         PREC_TYPE is INTEGER",
       "    Specifies the intermediate precision to be used in refinement.",
       "    The value is defined by ILAPREC(P) where P is a CHARACTER and",
       "    P    = 'S':  Single",
       "         = 'D':  Double",
       "         = 'I':  Indigenous",
       "         = 'X', 'E':  Extra"],
     "TRANS_TYPE"=>
      ["[in]",
       "         TRANS_TYPE is INTEGER",
       "    Specifies the transposition operation on A.",
       "    The value is defined by ILATRANS(T) where T is a CHARACTER and",
       "    T    = 'N':  No transpose",
       "         = 'T':  Transpose",
       "         = 'C':  Conjugate transpose"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "    The number of subdiagonals within the band of A.  KL >= 0."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "    The number of superdiagonals within the band of A.  KU >= 0"],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right-hand-sides, i.e., the number of columns of the",
       "    matrix B."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         On entry, the N-by-N matrix AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDBA >= max(1,N)."],
     "AFB"=>
      ["[in]",
       "         AFB is DOUBLE PRECISION array, dimension (LDAFB,N)",
       "    The factors L and U from the factorization",
       "    A = P*L*U as computed by DGBTRF."],
     "LDAFB"=>
      ["[in]",
       "         LDAFB is INTEGER",
       "    The leading dimension of the array AF.  LDAFB >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    The pivot indices from the factorization A = P*L*U",
       "    as computed by DGBTRF; row i of the matrix was interchanged",
       "    with row IPIV(i)."],
     "COLEQU"=>
      ["[in]",
       "         COLEQU is LOGICAL",
       "    If .TRUE. then column equilibration was done to A before calling",
       "    this routine. This is needed to compute the solution and error",
       "    bounds correctly."],
     "C"=>
      ["[in]",
       "         C is DOUBLE PRECISION array, dimension (N)",
       "    The column scale factors for A. If COLEQU = .FALSE., C",
       "    is not accessed. If C is input, each element of C should be a power",
       "    of the radix to ensure a reliable solution and error estimates.",
       "    Scaling by powers of the radix does not cause rounding errors unless",
       "    the result underflows or overflows. Rounding errors during scaling",
       "    lead to refining with a matrix that is not equivalent to the",
       "    input matrix, producing error estimates that may not be",
       "    reliable."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "    The right-hand-side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "Y"=>
      ["[in,out]",
       "         Y is DOUBLE PRECISION array, dimension",
       "                   (LDY,NRHS)",
       "    On entry, the solution matrix X, as computed by DGBTRS.",
       "    On exit, the improved solution matrix Y."],
     "LDY"=>
      ["[in]",
       "         LDY is INTEGER",
       "    The leading dimension of the array Y.  LDY >= max(1,N)."],
     "BERR_OUT"=>
      ["[out]",
       "         BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)",
       "    On exit, BERR_OUT(j) contains the componentwise relative backward",
       "    error for right-hand-side j from the formula",
       "        max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
       "    where abs(Z) is the componentwise absolute value of the matrix",
       "    or vector Z. This is computed by DLA_LIN_BERR."],
     "N_NORMS"=>
      ["[in]",
       "         N_NORMS is INTEGER",
       "    Determines which error bounds to return (see ERR_BNDS_NORM",
       "    and ERR_BNDS_COMP).",
       "    If N_NORMS >= 1 return normwise error bounds.",
       "    If N_NORMS >= 2 return componentwise error bounds."],
     "ERR_BNDS_NORM"=>
      ["[in,out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[in,out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension",
       "                   (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * slamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * slamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * slamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    This subroutine is only responsible for setting the second field",
       "    above.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "RES"=>
      ["[in]",
       "         RES is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the intermediate residual."],
     "AYB"=>
      ["[in]",
       "         AYB is DOUBLE PRECISION array, dimension (N)",
       "    Workspace. This can be the same workspace passed for Y_TAIL."],
     "DY"=>
      ["[in]",
       "         DY is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the intermediate solution."],
     "Y_TAIL"=>
      ["[in]",
       "         Y_TAIL is DOUBLE PRECISION array, dimension (N)",
       "    Workspace to hold the trailing bits of the intermediate solution."],
     "RCOND"=>
      ["[in]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "ITHRESH"=>
      ["[in]",
       "         ITHRESH is INTEGER",
       "    The maximum number of residual computations allowed for",
       "    refinement. The default is 10. For 'aggressive' set to 100 to",
       "    permit convergence using approximate factorizations or",
       "    factorizations other than LU. If the factorization uses a",
       "    technique other than Gaussian elimination, the guarantees in",
       "    ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy."],
     "RTHRESH"=>
      ["[in]",
       "         RTHRESH is DOUBLE PRECISION",
       "    Determines when to stop refinement if the error estimate stops",
       "    decreasing. Refinement will stop when the next solution no longer",
       "    satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is",
       "    the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The",
       "    default value is 0.5. For 'aggressive' set to 0.9 to permit",
       "    convergence on extremely ill-conditioned matrices. See LAWN 165",
       "    for more details."],
     "DZ_UB"=>
      ["[in]",
       "         DZ_UB is DOUBLE PRECISION",
       "    Determines when to start considering componentwise convergence.",
       "    Componentwise convergence is only considered after each component",
       "    of the solution Y is stable, which we definte as the relative",
       "    change in each component being less than DZ_UB. The default value",
       "    is 0.25, requiring the first bit to be stable. See LAWN 165 for",
       "    more details."],
     "IGNORE_CWISE"=>
      ["[in]",
       "         IGNORE_CWISE is LOGICAL",
       "    If .TRUE. then ignore componentwise convergence. Default value",
       "    is .FALSE.."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "      < 0:  if INFO = -i, the ith argument to DGBTRS had an illegal",
       "            value"]}},
 "cgelss"=>
  {"summary"=>
    ["CGELSS computes the minimum norm solution to a complex linear",
     "least squares problem:",
     "Minimize 2-norm(| b - A*x |).",
     "using the singular value decomposition (SVD) of A. A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix",
     "X.",
     "The effective rank of A is determined by treating as zero those",
     "singular values which are less than RCOND times the largest singular",
     "value."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the first min(m,n) rows of A are overwritten with",
       "         its right singular vectors, stored rowwise."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, B is overwritten by the N-by-NRHS solution matrix X.",
       "         If m >= n and RANK = n, the residual sum-of-squares for",
       "         the solution in the i-th column is given by the sum of",
       "         squares of the modulus of elements n+1:m in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M,N)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (min(M,N))",
       "         The singular values of A in decreasing order.",
       "         The condition number of A in the 2-norm = S(1)/S(min(m,n))."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "         RCOND is used to determine the effective rank of A.",
       "         Singular values S(i) <= RCOND*S(1) are treated as zero.",
       "         If RCOND < 0, machine precision is used instead."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the number of singular values",
       "         which are greater than RCOND*S(1)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= 1, and also:",
       "         LWORK >=  2*min(M,N) + max(M,N,NRHS)",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]", "         RWORK is REAL array, dimension (5*min(M,N))"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  the algorithm for computing the SVD failed to converge;",
       "               if INFO = i, i off-diagonal elements of an intermediate",
       "               bidiagonal form did not converge to zero."]}},
 "zgerfs"=>
  {"summary"=>
    ["ZGERFS improves the computed solution to a system of linear",
     "equations and provides error bounds and backward error estimates for",
     "the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The original N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX*16 array, dimension (LDAF,N)",
       "         The factors L and U from the factorization A = P*L*U",
       "         as computed by ZGETRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices from ZGETRF; for 1<=i<=N, row i of the",
       "         matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by ZGETRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cgelqf"=>
  {"summary"=>
    ["CGELQF computes an LQ factorization of a complex M-by-N matrix A:",
     "A = L * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the m-by-min(m,n) lower trapezoidal matrix L (L is",
       "         lower triangular if m <= n); the elements above the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlanhp"=>
  {"summary"=>
    ["ZLANHP  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the  element of  largest absolute value  of a",
     "complex hermitian matrix A,  supplied in packed form.",
     "   ZLANHP = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in ZLANHP as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         hermitian matrix A is supplied.",
       "         = 'U':  Upper triangular part of A is supplied",
       "         = 'L':  Lower triangular part of A is supplied"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, ZLANHP is",
       "         set to zero."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The upper or lower triangle of the hermitian matrix A, packed",
       "         columnwise in a linear array.  The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.",
       "         Note that the  imaginary parts of the diagonal elements need",
       "         not be set and are assumed to be zero."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,",
       "         WORK is not referenced."]}},
 "sgesc2"=>
  {"summary"=>
    ["SGESC2 solves a system of linear equations",
     "          A * X = scale* RHS",
     "with a general N-by-N matrix A using the LU factorization with",
     "complete pivoting computed by SGETC2."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix A."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the  LU part of the factorization of the n-by-n",
       "         matrix A computed by SGETC2:  A = P * L * U * Q"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1, N)."],
     "RHS"=>
      ["[in,out]",
       "         RHS is REAL array, dimension (N).",
       "         On entry, the right hand side vector b.",
       "         On exit, the solution vector X."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= i <= N, row i of the",
       "         matrix has been interchanged with row IPIV(i)."],
     "JPIV"=>
      ["[in]",
       "         JPIV is INTEGER array, dimension (N).",
       "         The pivot indices; for 1 <= j <= N, column j of the",
       "         matrix has been interchanged with column JPIV(j)."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "          On exit, SCALE contains the scale factor. SCALE is chosen",
       "          0 <= SCALE <= 1 to prevent owerflow in the solution."]}},
 "sgsvj1"=>
  {"summary"=>
    ["SGSVJ1 is called from SGESVJ as a pre-processor and that is its main",
     "purpose. It applies Jacobi rotations in the same way as SGESVJ does, but",
     "it targets only particular pivots and it does not check convergence",
     "(stopping criterion). Few tunning parameters (marked by [TP]) are",
     "available for the implementer.",
     "Further Details",
     "~~~~~~~~~~~~~~~",
     "SGSVJ1 applies few sweeps of Jacobi rotations in the column space of",
     "the input M-by-N matrix A. The pivot pairs are taken from the (1,2)",
     "off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The",
     "block-entries (tiles) of the (1,2) off-diagonal block are marked by the",
     "[x]'s in the following scheme:",
     "   | *  *  * [x] [x] [x]|",
     "   | *  *  * [x] [x] [x]|    Row-cycling in the nblr-by-nblc [x] blocks.",
     "   | *  *  * [x] [x] [x]|    Row-cyclic pivoting inside each [x] block.",
     "   |[x] [x] [x] *  *  * |",
     "   |[x] [x] [x] *  *  * |",
     "   |[x] [x] [x] *  *  * |",
     "In terms of the columns of A, the first N1 columns are rotated 'against'",
     "the remaining N-N1 columns, trying to increase the angle between the",
     "corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is",
     "tiled using quadratic tiles of side KBL. Here, KBL is a tunning parmeter.",
     "The number of sweeps is given in NSWEEP and the orthogonality threshold",
     "is given in TOL."],
   "param"=>
    {"JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether the output from this procedure is used",
       "         to compute the matrix V:",
       "         = 'V': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the N-by-N array V.",
       "               (See the description of V.)",
       "         = 'A': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the MV-by-N array V.",
       "               (See the descriptions of MV and V.)",
       "         = 'N': the Jacobi rotations are not accumulated."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         N1 specifies the 2 x 2 block partition, the first N1 columns are",
       "         rotated 'against' the remaining N-N1 columns of A."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, M-by-N matrix A, such that A*diag(D) represents",
       "         the input matrix.",
       "         On exit,",
       "         A_onexit * D_onexit represents the input matrix A*diag(D)",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of N1, D, TOL and NSWEEP.)"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         The array D accumulates the scaling factors from the fast scaled",
       "         Jacobi rotations.",
       "         On entry, A*diag(D) represents the input matrix.",
       "         On exit, A_onexit*diag(D_onexit) represents the input matrix",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of N1, A, TOL and NSWEEP.)"],
     "SVA"=>
      ["[in,out]",
       "         SVA is REAL array, dimension (N)",
       "         On entry, SVA contains the Euclidean norms of the columns of",
       "         the matrix A*diag(D).",
       "         On exit, SVA contains the Euclidean norms of the columns of",
       "         the matrix onexit*diag(D_onexit)."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then MV is not referenced."],
     "V"=>
      ["[in,out]",
       "         V is REAL array, dimension (LDV,N)",
       "         If JOBV .EQ. 'V' then N rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV .EQ. 'A' then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V', LDV .GE. N.",
       "         If JOBV = 'A', LDV .GE. MV."],
     "EPS"=>
      ["[in]", "         EPS is REAL", "         EPS = SLAMCH('Epsilon')"],
     "SFMIN"=>
      ["[in]",
       "         SFMIN is REAL",
       "         SFMIN = SLAMCH('Safe Minimum')"],
     "TOL"=>
      ["[in]",
       "         TOL is REAL",
       "         TOL is the threshold for Jacobi rotations. For a pair",
       "         A(:,p), A(:,q) of pivot columns, the Jacobi rotation is",
       "         applied only if ABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL."],
     "NSWEEP"=>
      ["[in]",
       "         NSWEEP is INTEGER",
       "         NSWEEP is the number of sweeps of Jacobi rotations to be",
       "         performed."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         LWORK is the dimension of WORK. LWORK .GE. M."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value"]}},
 "dgesv"=>
  {"summary"=>
    ["DGESV computes the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N matrix and X and B are N-by-NRHS matrices.",
     "The LU decomposition with partial pivoting and row interchanges is",
     "used to factor A as",
     "   A = P * L * U,",
     "where P is a permutation matrix, L is unit lower triangular, and U is",
     "upper triangular.  The factored form of A is then used to solve the",
     "system of equations A * X = B."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the N-by-N coefficient matrix A.",
       "         On exit, the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices that define the permutation matrix P;",
       "         row i of the matrix was interchanged with row IPIV(i)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS matrix of right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) is exactly zero.  The factorization",
       "               has been completed, but the factor U is exactly",
       "               singular, so the solution could not be computed."]}},
 "slatps"=>
  {"summary"=>
    ["SLATPS solves one of the triangular systems",
     "   A *x = s*b  or  A**T*x = s*b",
     "with scaling to prevent overflow, where A is an upper or lower",
     "triangular matrix stored in packed form.  Here A**T denotes the",
     "transpose of A, x and b are n-element vectors, and s is a scaling",
     "factor, usually less than or equal to 1, chosen so that the",
     "components of x will be less than the overflow threshold.  If the",
     "unscaled problem will not cause overflow, the Level 2 BLAS routine",
     "STPSV is called. If the matrix A is singular (A(j,j) = 0 for some j),",
     "then s is set to 0 and a non-trivial solution to A*x = 0 is returned."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the operation applied to A.",
       "         = 'N':  Solve A * x = s*b  (No transpose)",
       "         = 'T':  Solve A**T* x = s*b  (Transpose)",
       "         = 'C':  Solve A**T* x = s*b  (Conjugate transpose = Transpose)"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "NORMIN"=>
      ["[in]",
       "         NORMIN is CHARACTER*1",
       "         Specifies whether CNORM has been set or not.",
       "         = 'Y':  CNORM contains the column norms on entry",
       "         = 'N':  CNORM is not set on entry.  On exit, the norms will",
       "                 be computed and stored in CNORM."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         The upper or lower triangular matrix A, packed columnwise in",
       "         a linear array.  The j-th column of A is stored in the array",
       "         AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension (N)",
       "         On entry, the right hand side b of the triangular system.",
       "         On exit, X is overwritten by the solution vector x."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         The scaling factor s for the triangular system",
       "            A * x = s*b  or  A**T* x = s*b.",
       "         If SCALE = 0, the matrix A is singular or badly scaled, and",
       "         the vector x is an exact or approximate solution to A*x = 0."],
     "CNORM"=>
      ["[in,out]",
       "         CNORM is REAL array, dimension (N)",
       "         If NORMIN = 'Y', CNORM is an input argument and CNORM(j)",
       "         contains the norm of the off-diagonal part of the j-th column",
       "         of A.  If TRANS = 'N', CNORM(j) must be greater than or equal",
       "         to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)",
       "         must be greater than or equal to the 1-norm.",
       "         If NORMIN = 'N', CNORM is an output argument and CNORM(j)",
       "         returns the 1-norm of the offdiagonal part of the j-th column",
       "         of A."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -k, the k-th argument had an illegal value"]}},
 "cunmqr"=>
  {"summary"=>
    ["CUNMQR overwrites the general complex M-by-N matrix C with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "where Q is a complex unitary matrix defined as the product of k",
     "elementary reflectors",
     "      Q = H(1) H(2) . . . H(k)",
     "as returned by CGEQRF. Q is of order M if SIDE = 'L' and of order N",
     "if SIDE = 'R'."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q or Q**H from the Left;",
       "         = 'R': apply Q or Q**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q;",
       "         = 'C':  Conjugate transpose, apply Q**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of elementary reflectors whose product defines",
       "         the matrix Q.",
       "         If SIDE = 'L', M >= K >= 0;",
       "         if SIDE = 'R', N >= K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,K)",
       "         The i-th column must contain the vector which defines the",
       "         elementary reflector H(i), for i = 1,2,...,k, as returned by",
       "         CGEQRF in the first k columns of its array argument A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If SIDE = 'L', LDA >= max(1,M);",
       "         if SIDE = 'R', LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by CGEQRF."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M).",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zlacrt"=>
  {"summary"=>
    ["ZLACRT performs the operation",
     "   (  c  s )( x )  ==> ( x )",
     "   ( -s  c )( y )      ( y )",
     "where c and s are complex and the vectors x and y are complex."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements in the vectors CX and CY."],
     "CX"=>
      ["[in,out]",
       "         CX is COMPLEX*16 array, dimension (N)",
       "         On input, the vector x.",
       "         On output, CX is overwritten with c*x + s*y."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between successive values of CX.  INCX <> 0."],
     "CY"=>
      ["[in,out]",
       "         CY is COMPLEX*16 array, dimension (N)",
       "         On input, the vector y.",
       "         On output, CY is overwritten with -s*x + c*y."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between successive values of CY.  INCY <> 0."],
     "C"=>["[in]", "         C is COMPLEX*16"],
     "S"=>
      ["[in]",
       "         S is COMPLEX*16",
       "         C and S define the matrix",
       "            [  C   S  ].",
       "            [ -S   C  ]"]}},
 "slaqr1"=>
  {"summary"=>
    ["     Given a 2-by-2 or 3-by-3 matrix H, SLAQR1 sets v to a",
     "     scalar multiple of the first column of the product",
     "     (*)  K = (H - (sr1 + i*si1)*I)*(H - (sr2 + i*si2)*I)",
     "     scaling to avoid overflows and most underflows. It",
     "     is assumed that either",
     "             1) sr1 = sr2 and si1 = -si2",
     "         or",
     "             2) si1 = si2 = 0.",
     "     This is useful for starting double implicit shift bulges",
     "     in the QR algorithm."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is integer",
       "             Order of the matrix H. N must be either 2 or 3."],
     "H"=>
      ["[in]",
       "         H is REAL array of dimension (LDH,N)",
       "             The 2-by-2 or 3-by-3 matrix H in (*)."],
     "LDH"=>
      ["[in]",
       "         LDH is integer",
       "             The leading dimension of H as declared in",
       "             the calling procedure.  LDH.GE.N"],
     "SR1"=>["[in]", "         SR1 is REAL"],
     "SI1"=>["[in]", "         SI1 is REAL"],
     "SR2"=>["[in]", "         SR2 is REAL"],
     "SI2"=>
      ["[in]", "         SI2 is REAL", "             The shifts in (*)."],
     "V"=>
      ["[out]",
       "         V is REAL array of dimension N",
       "             A scalar multiple of the first column of the",
       "             matrix K in (*)."]}},
 "ssbgv"=>
  {"summary"=>
    ["SSBGV computes all the eigenvalues, and optionally, the eigenvectors",
     "of a real generalized symmetric-definite banded eigenproblem, of",
     "the form A*x=(lambda)*B*x. Here A and B are assumed to be symmetric",
     "and banded, and B is also positive definite."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangles of A and B are stored;",
       "         = 'L':  Lower triangles of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A and B.  N >= 0."],
     "KA"=>
      ["[in]",
       "         KA is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KA >= 0."],
     "KB"=>
      ["[in]",
       "         KB is INTEGER",
       "         The number of superdiagonals of the matrix B if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'. KB >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is REAL array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix A, stored in the first ka+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).",
       "         On exit, the contents of AB are destroyed."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KA+1."],
     "BB"=>
      ["[in,out]",
       "         BB is REAL array, dimension (LDBB, N)",
       "         On entry, the upper or lower triangle of the symmetric band",
       "         matrix B, stored in the first kb+1 rows of the array.  The",
       "         j-th column of B is stored in the j-th column of the array BB",
       "         as follows:",
       "         if UPLO = 'U', BB(kb+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;",
       "         if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).",
       "         On exit, the factor S from the split Cholesky factorization",
       "         B = S**T*S, as returned by SPBSTF."],
     "LDBB"=>
      ["[in]",
       "         LDBB is INTEGER",
       "         The leading dimension of the array BB.  LDBB >= KB+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of",
       "         eigenvectors, with the i-th column of Z holding the",
       "         eigenvector associated with W(i). The eigenvectors are",
       "         normalized so that Z**T*B*Z = I.",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= N."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, and i is:",
       "            <= N:  the algorithm failed to converge:",
       "                   i off-diagonal elements of an intermediate",
       "                   tridiagonal form did not converge to zero;",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then SPBSTF",
       "                   returned INFO = i: B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "stbcon"=>
  {"summary"=>
    ["STBCON estimates the reciprocal of the condition number of a",
     "triangular band matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlarfy"=>
  {"summary"=>
    ["DLARFY applies an elementary reflector, or Householder matrix, H,",
     "to an n x n symmetric matrix C, from both the left and the right.",
     "H is represented in the form",
     "   H = I - tau * v * v'",
     "where  tau  is a scalar and  v  is a vector.",
     "If  tau  is  zero, then  H  is taken to be the unit matrix."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix C is stored.",
       "         = 'U':  Upper triangle",
       "         = 'L':  Lower triangle"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows and columns of the matrix C.  N >= 0."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension",
       "                 (1 + (N-1)*abs(INCV))",
       "         The vector v as described above."],
     "INCV"=>
      ["[in]",
       "         INCV is INTEGER",
       "         The increment between successive elements of v.  INCV must",
       "         not be zero."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION",
       "         The value tau as described above."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC, N)",
       "         On entry, the matrix C.",
       "         On exit, C is overwritten by H * C * H'."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.  LDC >= max( 1, N )."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (N)"]}},
 "csyrfs"=>
  {"summary"=>
    ["CSYRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is symmetric indefinite, and",
     "provides error bounds and backward error estimates for the solution."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "         upper triangular part of A contains the upper triangular part",
       "         of the matrix A, and the strictly lower triangular part of A",
       "         is not referenced.  If UPLO = 'L', the leading N-by-N lower",
       "         triangular part of A contains the lower triangular part of",
       "         the matrix A, and the strictly upper triangular part of A is",
       "         not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "         The factored form of the matrix A.  AF contains the block",
       "         diagonal matrix D and the multipliers used to obtain the",
       "         factor U or L from the factorization A = U*D*U**T or",
       "         A = L*D*L**T as computed by CSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "         The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CSYTRF."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by CSYTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is REAL array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is REAL array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dgtsvx"=>
  {"summary"=>
    ["DGTSVX uses the LU factorization to compute the solution to a real",
     "system of linear equations A * X = B or A**T * X = B,",
     "where A is a tridiagonal matrix of order N and X and B are N-by-NRHS",
     "matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "zgelqf"=>
  {"summary"=>
    ["ZGELQF computes an LQ factorization of a complex M-by-N matrix A:",
     "A = L * Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the m-by-min(m,n) lower trapezoidal matrix L (L is",
       "         lower triangular if m <= n); the elements above the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX*16 array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,M).",
       "         For optimum performance LWORK >= M*NB, where NB is the",
       "         optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "slantb"=>
  {"summary"=>
    ["SLANTB  returns the value of the one norm,  or the Frobenius norm, or",
     "the  infinity norm,  or the element of  largest absolute value  of an",
     "n by n triangular band matrix A,  with ( k + 1 ) diagonals.",
     "   SLANTB = ( max(abs(A(i,j))), NORM = 'M' or 'm'",
     "            (",
     "            ( norm1(A),         NORM = '1', 'O' or 'o'",
     "            (",
     "            ( normI(A),         NORM = 'I' or 'i'",
     "            (",
     "            ( normF(A),         NORM = 'F', 'f', 'E' or 'e'",
     "where  norm1  denotes the  one norm of a matrix (maximum column sum),",
     "normI  denotes the  infinity norm  of a matrix  (maximum row sum) and",
     "normF  denotes the  Frobenius norm of a matrix (square root of sum of",
     "squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies the value to be returned in SLANTB as described",
       "         above."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the matrix A is upper or lower triangular.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         Specifies whether or not the matrix A is unit triangular.",
       "         = 'N':  Non-unit triangular",
       "         = 'U':  Unit triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0.  When N = 0, SLANTB is",
       "         set to zero."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals of the matrix A if UPLO = 'L'.",
       "         K >= 0."],
     "AB"=>
      ["[in]",
       "         AB is REAL array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first k+1 rows of AB.  The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)   = A(i,j) for j<=i<=min(n,j+k).",
       "         Note that when DIAG = 'U', the elements of the array AB",
       "         corresponding to the diagonal elements of the matrix A are",
       "         not referenced, but are assumed to be one."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= K+1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK)),",
       "         where LWORK >= N when NORM = 'I'; otherwise, WORK is not",
       "         referenced."]}},
 "dgtrfs"=>
  {"summary"=>
    ["DGTRFS improves the computed solution to a system of linear",
     "equations when the coefficient matrix is tridiagonal, and provides",
     "error bounds and backward error estimates for the solution."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         Specifies the form of the system of equations:",
       "         = 'N':  A * X = B     (No transpose)",
       "         = 'T':  A**T * X = B  (Transpose)",
       "         = 'C':  A**H * X = B  (Conjugate transpose = Transpose)"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "DL"=>
      ["[in]",
       "         DL is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) subdiagonal elements of A."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The diagonal elements of A."],
     "DU"=>
      ["[in]",
       "         DU is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) superdiagonal elements of A."],
     "DLF"=>
      ["[in]",
       "         DLF is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) multipliers that define the matrix L from the",
       "         LU factorization of A as computed by DGTTRF."],
     "DF"=>
      ["[in]",
       "         DF is DOUBLE PRECISION array, dimension (N)",
       "         The n diagonal elements of the upper triangular matrix U from",
       "         the LU factorization of A."],
     "DUF"=>
      ["[in]",
       "         DUF is DOUBLE PRECISION array, dimension (N-1)",
       "         The (n-1) elements of the first superdiagonal of U."],
     "DU2"=>
      ["[in]",
       "         DU2 is DOUBLE PRECISION array, dimension (N-2)",
       "         The (n-2) elements of the second superdiagonal of U."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices; for 1 <= i <= n, row i of the matrix was",
       "         interchanged with row IPIV(i).  IPIV(i) will always be either",
       "         i or i+1; IPIV(i) = i indicates a row interchange was not",
       "         required."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "         The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "         On entry, the solution matrix X, as computed by DGTTRS.",
       "         On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "FERR"=>
      ["[out]",
       "         FERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The estimated forward error bound for each solution vector",
       "         X(j) (the j-th column of the solution matrix X).",
       "         If XTRUE is the true solution corresponding to X(j), FERR(j)",
       "         is an estimated upper bound for the magnitude of the largest",
       "         element in (X(j) - XTRUE) divided by the magnitude of the",
       "         largest element in X(j).  The estimate is as reliable as",
       "         the estimate for RCOND, and is almost always a slight",
       "         overestimate of the true error."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "         The componentwise relative backward error of each solution",
       "         vector X(j) (i.e., the smallest relative change in",
       "         any element of A or B that makes X(j) an exact solution)."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cbdsqr"=>
  {"summary"=>
    ["CBDSQR computes the singular values and, optionally, the right and/or",
     "left singular vectors from the singular value decomposition (SVD) of",
     "a real N-by-N (upper or lower) bidiagonal matrix B using the implicit",
     "zero-shift QR algorithm.  The SVD of B has the form",
     "   B = Q * S * P**H",
     "where S is the diagonal matrix of singular values, Q is an orthogonal",
     "matrix of left singular vectors, and P is an orthogonal matrix of",
     "right singular vectors.  If left singular vectors are requested, this",
     "subroutine actually returns U*Q instead of Q, and, if right singular",
     "vectors are requested, this subroutine returns P**H*VT instead of",
     "P**H, for given complex input matrices U and VT.  When U and VT are",
     "the unitary matrices that reduce a general matrix A to bidiagonal",
     "form: A = U*B*VT, as computed by CGEBRD, then",
     "   A = (U*Q) * S * (P**H*VT)",
     "is the SVD of A.  Optionally, the subroutine may also compute Q**H*C",
     "for a given complex input matrix C.",
     "See \"Computing  Small Singular Values of Bidiagonal Matrices With",
     "Guaranteed High Relative Accuracy,\" by J. Demmel and W. Kahan,",
     "LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11,",
     "no. 5, pp. 873-912, Sept 1990) and",
     "\"Accurate singular values and differential qd algorithms,\" by",
     "B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics",
     "Department, University of California at Berkeley, July 1992",
     "for a detailed description of the algorithm."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  B is upper bidiagonal;",
       "         = 'L':  B is lower bidiagonal."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix B.  N >= 0."],
     "NCVT"=>
      ["[in]",
       "         NCVT is INTEGER",
       "         The number of columns of the matrix VT. NCVT >= 0."],
     "NRU"=>
      ["[in]",
       "         NRU is INTEGER",
       "         The number of rows of the matrix U. NRU >= 0."],
     "NCC"=>
      ["[in]",
       "         NCC is INTEGER",
       "         The number of columns of the matrix C. NCC >= 0."],
     "D"=>
      ["[in,out]",
       "         D is REAL array, dimension (N)",
       "         On entry, the n diagonal elements of the bidiagonal matrix B.",
       "         On exit, if INFO=0, the singular values of B in decreasing",
       "         order."],
     "E"=>
      ["[in,out]",
       "         E is REAL array, dimension (N-1)",
       "         On entry, the N-1 offdiagonal elements of the bidiagonal",
       "         matrix B.",
       "         On exit, if INFO = 0, E is destroyed; if INFO > 0, D and E",
       "         will contain the diagonal and superdiagonal elements of a",
       "         bidiagonal matrix orthogonally equivalent to the one given",
       "         as input."],
     "VT"=>
      ["[in,out]",
       "         VT is COMPLEX array, dimension (LDVT, NCVT)",
       "         On entry, an N-by-NCVT matrix VT.",
       "         On exit, VT is overwritten by P**H * VT.",
       "         Not referenced if NCVT = 0."],
     "LDVT"=>
      ["[in]",
       "         LDVT is INTEGER",
       "         The leading dimension of the array VT.",
       "         LDVT >= max(1,N) if NCVT > 0; LDVT >= 1 if NCVT = 0."],
     "U"=>
      ["[in,out]",
       "         U is COMPLEX array, dimension (LDU, N)",
       "         On entry, an NRU-by-N matrix U.",
       "         On exit, U is overwritten by U * Q.",
       "         Not referenced if NRU = 0."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U.  LDU >= max(1,NRU)."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC, NCC)",
       "         On entry, an N-by-NCC matrix C.",
       "         On exit, C is overwritten by Q**H * C.",
       "         Not referenced if NCC = 0."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C.",
       "         LDC >= max(1,N) if NCC > 0; LDC >=1 if NCC = 0."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (4*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  If INFO = -i, the i-th argument had an illegal value",
       "         > 0:  the algorithm did not converge; D and E contain the",
       "               elements of a bidiagonal matrix which is orthogonally",
       "               similar to the input matrix B;  if INFO = i, i",
       "               elements of E have not converged to zero."]}},
 "zlargv"=>
  {"summary"=>
    ["ZLARGV generates a vector of complex plane rotations with real",
     "cosines, determined by elements of the complex vectors x and y.",
     "For i = 1,2,...,n",
     "   (        c(i)   s(i) ) ( x(i) ) = ( r(i) )",
     "   ( -conjg(s(i))  c(i) ) ( y(i) ) = (   0  )",
     "   where c(i)**2 + ABS(s(i))**2 = 1",
     "The following conventions are used (these are the same as in ZLARTG,",
     "but differ from the BLAS1 routine ZROTG):",
     "   If y(i)=0, then c(i)=1 and s(i)=0.",
     "   If x(i)=0, then c(i)=0 and s(i) is chosen so that r(i) is real."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of plane rotations to be generated."],
     "X"=>
      ["[in,out]",
       "         X is COMPLEX*16 array, dimension (1+(N-1)*INCX)",
       "         On entry, the vector x.",
       "         On exit, x(i) is overwritten by r(i), for i = 1,...,n."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "Y"=>
      ["[in,out]",
       "         Y is COMPLEX*16 array, dimension (1+(N-1)*INCY)",
       "         On entry, the vector y.",
       "         On exit, the sines of the plane rotations."],
     "INCY"=>
      ["[in]",
       "         INCY is INTEGER",
       "         The increment between elements of Y. INCY > 0."],
     "C"=>
      ["[out]",
       "         C is DOUBLE PRECISION array, dimension (1+(N-1)*INCC)",
       "         The cosines of the plane rotations."],
     "INCC"=>
      ["[in]",
       "         INCC is INTEGER",
       "         The increment between elements of C. INCC > 0."]}},
 "claqr0"=>
  {"summary"=>
    ["   CLAQR0 computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**H, where T is an upper triangular matrix (the",
     "   Schur form), and Z is the unitary matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input unitary",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the unitary matrix Q:  A = Q*H*Q**H = (QZ)*H*(QZ)**H."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N and, if ILO.GT.1,",
       "          H(ILO,ILO-1) is zero. ILO and IHI are normally set by a",
       "          previous call to CGEBAL, and then passed to CGEHRD when the",
       "          matrix output by CGEBAL is reduced to Hessenberg form.",
       "          Otherwise, ILO and IHI should be set to 1 and N,",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and WANTT is .TRUE., then H",
       "          contains the upper triangular matrix T from the Schur",
       "          decomposition (the Schur form). If INFO = 0 and WANT is",
       "          .FALSE., then the contents of H are unspecified on exit.",
       "          (The output value of H when INFO.GT.0 is given under the",
       "          description of INFO below.)",
       "          This subroutine may explicitly set H(i,j) = 0 for i.GT.j and",
       "          j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "W"=>
      ["[out]",
       "         W is COMPLEX array, dimension (N)",
       "          The computed eigenvalues of H(ILO:IHI,ILO:IHI) are stored",
       "          in W(ILO:IHI). If WANTT is .TRUE., then the eigenvalues are",
       "          stored in the same order as on the diagonal of the Schur",
       "          form returned in H, with W(i) = H(i,i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "          Specify the rows of Z to which transformations must be",
       "          applied if WANTZ is .TRUE..",
       "          1 .LE. ILOZ .LE. ILO; IHI .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array, dimension (LDZ,IHI)",
       "          If WANTZ is .FALSE., then Z is not referenced.",
       "          If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is",
       "          replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the",
       "          orthogonal Schur factor of H(ILO:IHI,ILO:IHI).",
       "          (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if WANTZ is .TRUE.",
       "          then LDZ.GE.MAX(1,IHIZ).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension LWORK",
       "          On exit, if LWORK = -1, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient, but LWORK typically as large as 6*N may",
       "          be required for optimal performance.  A workspace query",
       "          to determine the optimal workspace size is recommended.",
       "          If LWORK = -1, then CLAQR0 does a workspace query.",
       "          In this case, CLAQR0 checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .GT. 0:  if INFO = i, CLAQR0 failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and WANT is .FALSE., then on exit,",
       "               the remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is a unitary matrix.  The final",
       "               value of  H is upper Hessenberg and triangular in",
       "               rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                 (final value of Z(ILO:IHI,ILOZ:IHIZ)",
       "                  =  (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U",
       "               where U is the unitary matrix in (*) (regard-",
       "               less of the value of WANTT.)",
       "               If INFO .GT. 0 and WANTZ is .FALSE., then Z is not",
       "               accessed."]}},
 "cgeqrf"=>
  {"summary"=>
    ["CGEQRF computes a QR factorization of a complex M-by-N matrix A:",
     "A = Q * R."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(M,N)-by-N upper trapezoidal matrix R (R is",
       "         upper triangular if m >= n); the elements below the diagonal,",
       "         with the array TAU, represent the unitary matrix Q as a",
       "         product of min(m,n) elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.  LWORK >= max(1,N).",
       "         For optimum performance LWORK >= N*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlaqr4"=>
  {"summary"=>
    ["   DLAQR4 implements one level of recursion for DLAQR0.",
     "   It is a complete implementation of the small bulge multi-shift",
     "   QR algorithm.  It may be called by DLAQR0 and, for large enough",
     "   deflation window size, it may be called by DLAQR3.  This",
     "   subroutine is identical to DLAQR0 except that it calls DLAQR2",
     "   instead of DLAQR3.",
     "   DLAQR4 computes the eigenvalues of a Hessenberg matrix H",
     "   and, optionally, the matrices T and Z from the Schur decomposition",
     "   H = Z T Z**T, where T is an upper quasi-triangular matrix (the",
     "   Schur form), and Z is the orthogonal matrix of Schur vectors.",
     "   Optionally Z may be postmultiplied into an input orthogonal",
     "   matrix Q so that this routine can give the Schur factorization",
     "   of a matrix A which has been reduced to the Hessenberg form H",
     "   by the orthogonal matrix Q:  A = Q*H*Q**T = (QZ)*T*(QZ)**T."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          The order of the matrix H.  N .GE. 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "          It is assumed that H is already upper triangular in rows",
       "          and columns 1:ILO-1 and IHI+1:N and, if ILO.GT.1,",
       "          H(ILO,ILO-1) is zero. ILO and IHI are normally set by a",
       "          previous call to DGEBAL, and then passed to DGEHRD when the",
       "          matrix output by DGEBAL is reduced to Hessenberg form.",
       "          Otherwise, ILO and IHI should be set to 1 and N,",
       "          respectively.  If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.",
       "          If N = 0, then ILO = 1 and IHI = 0."],
     "H"=>
      ["[in,out]",
       "         H is DOUBLE PRECISION array, dimension (LDH,N)",
       "          On entry, the upper Hessenberg matrix H.",
       "          On exit, if INFO = 0 and WANTT is .TRUE., then H contains",
       "          the upper quasi-triangular matrix T from the Schur",
       "          decomposition (the Schur form); 2-by-2 diagonal blocks",
       "          (corresponding to complex conjugate pairs of eigenvalues)",
       "          are returned in standard form, with H(i,i) = H(i+1,i+1)",
       "          and H(i+1,i)*H(i,i+1).LT.0. If INFO = 0 and WANTT is",
       "          .FALSE., then the contents of H are unspecified on exit.",
       "          (The output value of H when INFO.GT.0 is given under the",
       "          description of INFO below.)",
       "          This subroutine may explicitly set H(i,j) = 0 for i.GT.j and",
       "          j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "          The leading dimension of the array H. LDH .GE. max(1,N)."],
     "WR"=>["[out]", "         WR is DOUBLE PRECISION array, dimension (IHI)"],
     "WI"=>
      ["[out]",
       "         WI is DOUBLE PRECISION array, dimension (IHI)",
       "          The real and imaginary parts, respectively, of the computed",
       "          eigenvalues of H(ILO:IHI,ILO:IHI) are stored in WR(ILO:IHI)",
       "          and WI(ILO:IHI). If two eigenvalues are computed as a",
       "          complex conjugate pair, they are stored in consecutive",
       "          elements of WR and WI, say the i-th and (i+1)th, with",
       "          WI(i) .GT. 0 and WI(i+1) .LT. 0. If WANTT is .TRUE., then",
       "          the eigenvalues are stored in the same order as on the",
       "          diagonal of the Schur form returned in H, with",
       "          WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2 diagonal",
       "          block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and",
       "          WI(i+1) = -WI(i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "          Specify the rows of Z to which transformations must be",
       "          applied if WANTZ is .TRUE..",
       "          1 .LE. ILOZ .LE. ILO; IHI .LE. IHIZ .LE. N."],
     "Z"=>
      ["[in,out]",
       "         Z is DOUBLE PRECISION array, dimension (LDZ,IHI)",
       "          If WANTZ is .FALSE., then Z is not referenced.",
       "          If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is",
       "          replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the",
       "          orthogonal Schur factor of H(ILO:IHI,ILO:IHI).",
       "          (The output value of Z when INFO.GT.0 is given under",
       "          the description of INFO below.)"],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "          The leading dimension of the array Z.  if WANTZ is .TRUE.",
       "          then LDZ.GE.MAX(1,IHIZ).  Otherwize, LDZ.GE.1."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension LWORK",
       "          On exit, if LWORK = -1, WORK(1) returns an estimate of",
       "          the optimal value for LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "          The dimension of the array WORK.  LWORK .GE. max(1,N)",
       "          is sufficient, but LWORK typically as large as 6*N may",
       "          be required for optimal performance.  A workspace query",
       "          to determine the optimal workspace size is recommended.",
       "          If LWORK = -1, then DLAQR4 does a workspace query.",
       "          In this case, DLAQR4 checks the input parameters and",
       "          estimates the optimal workspace size for the given",
       "          values of N, ILO and IHI.  The estimate is returned",
       "          in WORK(1).  No error message related to LWORK is",
       "          issued by XERBLA.  Neither H nor Z are accessed."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "            =  0:  successful exit",
       "          .GT. 0:  if INFO = i, DLAQR4 failed to compute all of",
       "               the eigenvalues.  Elements 1:ilo-1 and i+1:n of WR",
       "               and WI contain those eigenvalues which have been",
       "               successfully computed.  (Failures are rare.)",
       "               If INFO .GT. 0 and WANT is .FALSE., then on exit,",
       "               the remaining unconverged eigenvalues are the eigen-",
       "               values of the upper Hessenberg matrix rows and",
       "               columns ILO through INFO of the final, output",
       "               value of H.",
       "               If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "          (*)  (initial value of H)*U  = U*(final value of H)",
       "               where U is a orthogonal matrix.  The final",
       "               value of  H is upper Hessenberg and triangular in",
       "               rows and columns INFO+1 through IHI.",
       "               If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                 (final value of Z(ILO:IHI,ILOZ:IHIZ)",
       "                  =  (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U",
       "               where U is the orthogonal matrix in (*) (regard-",
       "               less of the value of WANTT.)",
       "               If INFO .GT. 0 and WANTZ is .FALSE., then Z is not",
       "               accessed."]}},
 "claqr5"=>
  {"summary"=>
    ["   CLAQR5 called by CLAQR0 performs a",
     "   single small-bulge multi-shift QR sweep."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is logical scalar",
       "            WANTT = .true. if the triangular Schur factor",
       "            is being computed.  WANTT is set to .false. otherwise."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is logical scalar",
       "            WANTZ = .true. if the unitary Schur factor is being",
       "            computed.  WANTZ is set to .false. otherwise."],
     "KACC22"=>
      ["[in]",
       "         KACC22 is integer with value 0, 1, or 2.",
       "            Specifies the computation mode of far-from-diagonal",
       "            orthogonal updates.",
       "       = 0: CLAQR5 does not accumulate reflections and does not",
       "            use matrix-matrix multiply to update far-from-diagonal",
       "            matrix entries.",
       "       = 1: CLAQR5 accumulates reflections and uses matrix-matrix",
       "            multiply to update the far-from-diagonal matrix entries.",
       "       = 2: CLAQR5 accumulates reflections, uses matrix-matrix",
       "            multiply to update the far-from-diagonal matrix entries,",
       "            and takes advantage of 2-by-2 block structure during",
       "            matrix multiplies."],
     "N"=>
      ["[in]",
       "         N is integer scalar",
       "            N is the order of the Hessenberg matrix H upon which this",
       "            subroutine operates."],
     "KTOP"=>["[in]", "         KTOP is integer scalar"],
     "KBOT"=>
      ["[in]",
       "         KBOT is integer scalar",
       "            These are the first and last rows and columns of an",
       "            isolated diagonal block upon which the QR sweep is to be",
       "            applied. It is assumed without a check that",
       "                      either KTOP = 1  or   H(KTOP,KTOP-1) = 0",
       "            and",
       "                      either KBOT = N  or   H(KBOT+1,KBOT) = 0."],
     "NSHFTS"=>
      ["[in]",
       "         NSHFTS is integer scalar",
       "            NSHFTS gives the number of simultaneous shifts.  NSHFTS",
       "            must be positive and even."],
     "S"=>
      ["[in,out]",
       "         S is COMPLEX array of size (NSHFTS)",
       "            S contains the shifts of origin that define the multi-",
       "            shift QR sweep.  On output S may be reordered."],
     "H"=>
      ["[in,out]",
       "         H is COMPLEX array of size (LDH,N)",
       "            On input H contains a Hessenberg matrix.  On output a",
       "            multi-shift QR sweep with shifts SR(J)+i*SI(J) is applied",
       "            to the isolated diagonal block in rows and columns KTOP",
       "            through KBOT."],
     "LDH"=>
      ["[in]",
       "         LDH is integer scalar",
       "            LDH is the leading dimension of H just as declared in the",
       "            calling procedure.  LDH.GE.MAX(1,N)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "            Specify the rows of Z to which transformations must be",
       "            applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N"],
     "Z"=>
      ["[in,out]",
       "         Z is COMPLEX array of size (LDZ,IHIZ)",
       "            If WANTZ = .TRUE., then the QR Sweep unitary",
       "            similarity transformation is accumulated into",
       "            Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.",
       "            If WANTZ = .FALSE., then Z is unreferenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is integer scalar",
       "            LDA is the leading dimension of Z just as declared in",
       "            the calling procedure. LDZ.GE.N."],
     "V"=>["[out]", "         V is COMPLEX array of size (LDV,NSHFTS/2)"],
     "LDV"=>
      ["[in]",
       "         LDV is integer scalar",
       "            LDV is the leading dimension of V as declared in the",
       "            calling procedure.  LDV.GE.3."],
     "U"=>
      ["[out]",
       "         U is COMPLEX array of size",
       "            (LDU,3*NSHFTS-3)"],
     "LDU"=>
      ["[in]",
       "         LDU is integer scalar",
       "            LDU is the leading dimension of U just as declared in the",
       "            in the calling subroutine.  LDU.GE.3*NSHFTS-3."],
     "NH"=>
      ["[in]",
       "         NH is integer scalar",
       "            NH is the number of columns in array WH available for",
       "            workspace. NH.GE.1."],
     "WH"=>["[out]", "         WH is COMPLEX array of size (LDWH,NH)"],
     "LDWH"=>
      ["[in]",
       "         LDWH is integer scalar",
       "            Leading dimension of WH just as declared in the",
       "            calling procedure.  LDWH.GE.3*NSHFTS-3."],
     "NV"=>
      ["[in]",
       "         NV is integer scalar",
       "            NV is the number of rows in WV agailable for workspace.",
       "            NV.GE.1."],
     "WV"=>
      ["[out]",
       "         WV is COMPLEX array of size",
       "            (LDWV,3*NSHFTS-3)"],
     "LDWV"=>
      ["[in]",
       "         LDWV is integer scalar",
       "            LDWV is the leading dimension of WV as declared in the",
       "            in the calling subroutine.  LDWV.GE.NV."]}},
 "csytf2"=>
  {"summary"=>
    ["CSYTF2 computes the factorization of a complex symmetric matrix A",
     "using the Bunch-Kaufman diagonal pivoting method:",
     "   A = U*D*U**T  or  A = L*D*L**T",
     "where U (or L) is a product of permutation and unit upper (lower)",
     "triangular matrices, U**T is the transpose of U, and D is symmetric and",
     "block diagonal with 1-by-1 and 2-by-2 diagonal blocks.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, the block diagonal matrix D and the multipliers used",
       "         to obtain the factor U or L (see below for further details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D.",
       "         If UPLO = 'U':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k-1) < 0, then rows and columns",
       "            k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)",
       "            is a 2-by-2 diagonal block.",
       "         If UPLO = 'L':",
       "            If IPIV(k) > 0, then rows and columns k and IPIV(k) were",
       "            interchanged and D(k,k) is a 1-by-1 diagonal block.",
       "            If IPIV(k) = IPIV(k+1) < 0, then rows and columns",
       "            k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1)",
       "            is a 2-by-2 diagonal block."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, D(k,k) is exactly zero.  The factorization",
       "              has been completed, but the block diagonal matrix D is",
       "              exactly singular, and division by zero will occur if it",
       "              is used to solve a system of equations."]}},
 "zhfrk"=>
  {"summary"=>
    ["Level 3 BLAS like routine for C in RFP Format.",
     "ZHFRK performs one of the Hermitian rank--k operations",
     "   C := alpha*A*A**H + beta*C,",
     "or",
     "   C := alpha*A**H*A + beta*C,",
     "where alpha and beta are real scalars, C is an n--by--n Hermitian",
     "matrix and A is an n--by--k matrix in the first case and a k--by--n",
     "matrix in the second case."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal Form of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose Form of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On  entry,   UPLO  specifies  whether  the  upper  or  lower",
       "          triangular  part  of the  array  C  is to be  referenced  as",
       "          follows:",
       "             UPLO = 'U' or 'u'   Only the  upper triangular part of  C",
       "                                 is to be referenced.",
       "             UPLO = 'L' or 'l'   Only the  lower triangular part of  C",
       "                                 is to be referenced.",
       "          Unchanged on exit."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "          On entry,  TRANS  specifies the operation to be performed as",
       "          follows:",
       "             TRANS = 'N' or 'n'   C := alpha*A*A**H + beta*C.",
       "             TRANS = 'C' or 'c'   C := alpha*A**H*A + beta*C.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry,  N specifies the order of the matrix C.  N must be",
       "          at least zero.",
       "          Unchanged on exit."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "          On entry with  TRANS = 'N' or 'n',  K  specifies  the number",
       "          of  columns   of  the   matrix   A,   and  on   entry   with",
       "          TRANS = 'C' or 'c',  K  specifies  the number of rows of the",
       "          matrix A.  K must be at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is DOUBLE PRECISION",
       "          On entry, ALPHA specifies the scalar alpha.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array of DIMENSION (LDA,ka)",
       "          where KA",
       "          is K  when TRANS = 'N' or 'n', and is N otherwise. Before",
       "          entry with TRANS = 'N' or 'n', the leading N--by--K part of",
       "          the array A must contain the matrix A, otherwise the leading",
       "          K--by--N part of the array A must contain the matrix A.",
       "          Unchanged on exit."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "          On entry, LDA specifies the first dimension of A as declared",
       "          in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'",
       "          then  LDA must be at least  max( 1, n ), otherwise  LDA must",
       "          be at least  max( 1, k ).",
       "          Unchanged on exit."],
     "BETA"=>
      ["[in]",
       "         BETA is DOUBLE PRECISION",
       "          On entry, BETA specifies the scalar beta.",
       "          Unchanged on exit."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "          On entry, the matrix A in RFP Format. RFP Format is",
       "          described by TRANSR, UPLO and N. Note that the imaginary",
       "          parts of the diagonal elements need not be set, they are",
       "          assumed to be zero, and on exit they are set to zero."]}},
 "dtbcon"=>
  {"summary"=>
    ["DTBCON estimates the reciprocal of the condition number of a",
     "triangular band matrix A, in either the 1-norm or the infinity-norm.",
     "The norm of A is computed and an estimate is obtained for",
     "norm(inv(A)), then the reciprocal of the condition number is",
     "computed as",
     "   RCOND = 1 / ( norm(A) * norm(inv(A)) )."],
   "param"=>
    {"NORM"=>
      ["[in]",
       "         NORM is CHARACTER*1",
       "         Specifies whether the 1-norm condition number or the",
       "         infinity-norm condition number is required:",
       "         = '1' or 'O':  1-norm;",
       "         = 'I':         Infinity-norm."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular;",
       "         = 'L':  A is lower triangular."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "         = 'N':  A is non-unit triangular;",
       "         = 'U':  A is unit triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals or subdiagonals of the",
       "         triangular band matrix A.  KD >= 0."],
     "AB"=>
      ["[in]",
       "         AB is DOUBLE PRECISION array, dimension (LDAB,N)",
       "         The upper or lower triangular band matrix A, stored in the",
       "         first kd+1 rows of the array. The j-th column of A is stored",
       "         in the j-th column of the array AB as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         If DIAG = 'U', the diagonal elements of A are not referenced",
       "         and are assumed to be 1."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(norm(A) * norm(inv(A)))."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (3*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ssygvx"=>
  {"summary"=>
    ["SSYGVX computes selected eigenvalues, and optionally, eigenvectors",
     "of a real generalized symmetric-definite eigenproblem, of the form",
     "A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A",
     "and B are assumed to be symmetric and B is also positive definite.",
     "Eigenvalues and eigenvectors can be selected by specifying either a",
     "range of values or a range of indices for the desired eigenvalues."],
   "param"=>
    {"ITYPE"=>
      ["[in]",
       "         ITYPE is INTEGER",
       "         Specifies the problem type to be solved:",
       "         = 1:  A*x = (lambda)*B*x",
       "         = 2:  A*B*x = (lambda)*x",
       "         = 3:  B*A*x = (lambda)*x"],
     "JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "RANGE"=>
      ["[in]",
       "         RANGE is CHARACTER*1",
       "         = 'A': all eigenvalues will be found.",
       "         = 'V': all eigenvalues in the half-open interval (VL,VU]",
       "                will be found.",
       "         = 'I': the IL-th through IU-th eigenvalues will be found."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A and B are stored;",
       "         = 'L':  Lower triangle of A and B are stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix pencil (A,B).  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of A contains the",
       "         upper triangular part of the matrix A.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of A contains",
       "         the lower triangular part of the matrix A.",
       "         On exit, the lower triangle (if UPLO='L') or the upper",
       "         triangle (if UPLO='U') of A, including the diagonal, is",
       "         destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is REAL array, dimension (LDA, N)",
       "         On entry, the symmetric matrix B.  If UPLO = 'U', the",
       "         leading N-by-N upper triangular part of B contains the",
       "         upper triangular part of the matrix B.  If UPLO = 'L',",
       "         the leading N-by-N lower triangular part of B contains",
       "         the lower triangular part of the matrix B.",
       "         On exit, if INFO <= N, the part of B containing the matrix is",
       "         overwritten by the triangular factor U or L from the Cholesky",
       "         factorization B = U**T*U or B = L*L**T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "VL"=>
      ["[in]",
       "         VL is REAL",
       "         If RANGE='V', the lower bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "VU"=>
      ["[in]",
       "         VU is REAL",
       "         If RANGE='V', the upper bound of the interval to",
       "         be searched for eigenvalues. VL < VU.",
       "         Not referenced if RANGE = 'A' or 'I'."],
     "IL"=>
      ["[in]",
       "         IL is INTEGER",
       "         If RANGE='I', the index of the",
       "         smallest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "IU"=>
      ["[in]",
       "         IU is INTEGER",
       "         If RANGE='I', the index of the",
       "         largest eigenvalue to be returned.",
       "         1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0.",
       "         Not referenced if RANGE = 'A' or 'V'."],
     "ABSTOL"=>
      ["[in]",
       "         ABSTOL is REAL",
       "         The absolute error tolerance for the eigenvalues.",
       "         An approximate eigenvalue is accepted as converged",
       "         when it is determined to lie in an interval [a,b]",
       "         of width less than or equal to",
       "                 ABSTOL + EPS *   max( |a|,|b| ) ,",
       "         where EPS is the machine precision.  If ABSTOL is less than",
       "         or equal to zero, then  EPS*|T|  will be used in its place,",
       "         where |T| is the 1-norm of the tridiagonal matrix obtained",
       "         by reducing C to tridiagonal form, where C is the symmetric",
       "         matrix of the standard symmetric problem to which the",
       "         generalized problem is transformed.",
       "         Eigenvalues will be computed most accurately when ABSTOL is",
       "         set to twice the underflow threshold 2*DLAMCH('S'), not zero.",
       "         If this routine returns with INFO>0, indicating that some",
       "         eigenvectors did not converge, try setting ABSTOL to",
       "         2*SLAMCH('S')."],
     "M"=>
      ["[out]",
       "         M is INTEGER",
       "         The total number of eigenvalues found.  0 <= M <= N.",
       "         If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         On normal exit, the first M elements contain the selected",
       "         eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, max(1,M))",
       "         If JOBZ = 'N', then Z is not referenced.",
       "         If JOBZ = 'V', then if INFO = 0, the first M columns of Z",
       "         contain the orthonormal eigenvectors of the matrix A",
       "         corresponding to the selected eigenvalues, with the i-th",
       "         column of Z holding the eigenvector associated with W(i).",
       "         The eigenvectors are normalized as follows:",
       "         if ITYPE = 1 or 2, Z**T*B*Z = I;",
       "         if ITYPE = 3, Z**T*inv(B)*Z = I.",
       "         If an eigenvector fails to converge, then that column of Z",
       "         contains the latest approximation to the eigenvector, and the",
       "         index of the eigenvector is returned in IFAIL.",
       "         Note: the user must ensure that at least max(1,M) columns are",
       "         supplied in the array Z; if RANGE = 'V', the exact value of M",
       "         is not known in advance and an upper bound must be used."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,8*N).",
       "         For optimal efficiency, LWORK >= (NB+3)*N,",
       "         where NB is the blocksize for SSYTRD returned by ILAENV.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (5*N)"],
     "IFAIL"=>
      ["[out]",
       "         IFAIL is INTEGER array, dimension (N)",
       "         If JOBZ = 'V', then if INFO = 0, the first M elements of",
       "         IFAIL are zero.  If INFO > 0, then IFAIL contains the",
       "         indices of the eigenvectors that failed to converge.",
       "         If JOBZ = 'N', then IFAIL is not referenced."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  SPOTRF or SSYEVX returned an error code:",
       "            <= N:  if INFO = i, SSYEVX failed to converge;",
       "                   i eigenvectors failed to converge.  Their indices",
       "                   are stored in array IFAIL.",
       "            > N:   if INFO = N + i, for 1 <= i <= N, then the leading",
       "                   minor of order i of B is not positive definite.",
       "                   The factorization of B could not be completed and",
       "                   no eigenvalues or eigenvectors were computed."]}},
 "zgsvj1"=>
  {"summary"=>
    ["ZGSVJ1 is called from ZGESVJ as a pre-processor and that is its main",
     "purpose. It applies Jacobi rotations in the same way as ZGESVJ does, but",
     "it targets only particular pivots and it does not check convergence",
     "(stopping criterion). Few tunning parameters (marked by [TP]) are",
     "available for the implementer.",
     "Further Details",
     "~~~~~~~~~~~~~~~",
     "ZGSVJ1 applies few sweeps of Jacobi rotations in the column space of",
     "the input M-by-N matrix A. The pivot pairs are taken from the (1,2)",
     "off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The",
     "block-entries (tiles) of the (1,2) off-diagonal block are marked by the",
     "[x]'s in the following scheme:",
     "   | *  *  * [x] [x] [x]|",
     "   | *  *  * [x] [x] [x]|    Row-cycling in the nblr-by-nblc [x] blocks.",
     "   | *  *  * [x] [x] [x]|    Row-cyclic pivoting inside each [x] block.",
     "   |[x] [x] [x] *  *  * |",
     "   |[x] [x] [x] *  *  * |",
     "   |[x] [x] [x] *  *  * |",
     "In terms of the columns of A, the first N1 columns are rotated 'against'",
     "the remaining N-N1 columns, trying to increase the angle between the",
     "corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is",
     "tiled using quadratic tiles of side KBL. Here, KBL is a tunning parmeter.",
     "The number of sweeps is given in NSWEEP and the orthogonality threshold",
     "is given in TOL."],
   "param"=>
    {"JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         Specifies whether the output from this procedure is used",
       "         to compute the matrix V:",
       "         = 'V': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the N-by-N array V.",
       "               (See the description of V.)",
       "         = 'A': the product of the Jacobi rotations is accumulated",
       "                by postmulyiplying the MV-by-N array V.",
       "               (See the descriptions of MV and V.)",
       "         = 'N': the Jacobi rotations are not accumulated."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the input matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the input matrix A.",
       "         M >= N >= 0."],
     "N1"=>
      ["[in]",
       "         N1 is INTEGER",
       "         N1 specifies the 2 x 2 block partition, the first N1 columns are",
       "         rotated 'against' the remaining N-N1 columns of A."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, M-by-N matrix A, such that A*diag(D) represents",
       "         the input matrix.",
       "         On exit,",
       "         A_onexit * D_onexit represents the input matrix A*diag(D)",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of N1, D, TOL and NSWEEP.)"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[in,out]",
       "         D is COMPLEX*16 array, dimension (N)",
       "         The array D accumulates the scaling factors from the fast scaled",
       "         Jacobi rotations.",
       "         On entry, A*diag(D) represents the input matrix.",
       "         On exit, A_onexit*diag(D_onexit) represents the input matrix",
       "         post-multiplied by a sequence of Jacobi rotations, where the",
       "         rotation threshold and the total number of sweeps are given in",
       "         TOL and NSWEEP, respectively.",
       "         (See the descriptions of N1, A, TOL and NSWEEP.)"],
     "SVA"=>
      ["[in,out]",
       "         SVA is DOUBLE PRECISION array, dimension (N)",
       "         On entry, SVA contains the Euclidean norms of the columns of",
       "         the matrix A*diag(D).",
       "         On exit, SVA contains the Euclidean norms of the columns of",
       "         the matrix onexit*diag(D_onexit)."],
     "MV"=>
      ["[in]",
       "         MV is INTEGER",
       "         If JOBV .EQ. 'A', then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then MV is not referenced."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX*16 array, dimension (LDV,N)",
       "         If JOBV .EQ. 'V' then N rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV .EQ. 'A' then MV rows of V are post-multipled by a",
       "                          sequence of Jacobi rotations.",
       "         If JOBV = 'N',   then V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V,  LDV >= 1.",
       "         If JOBV = 'V', LDV .GE. N.",
       "         If JOBV = 'A', LDV .GE. MV."],
     "EPS"=>
      ["[in]",
       "         EPS is DOUBLE PRECISION",
       "         EPS = DLAMCH('Epsilon')"],
     "SFMIN"=>
      ["[in]",
       "         SFMIN is DOUBLE PRECISION",
       "         SFMIN = DLAMCH('Safe Minimum')"],
     "TOL"=>
      ["[in]",
       "         TOL is DOUBLE PRECISION",
       "         TOL is the threshold for Jacobi rotations. For a pair",
       "         A(:,p), A(:,q) of pivot columns, the Jacobi rotation is",
       "         applied only if ABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL."],
     "NSWEEP"=>
      ["[in]",
       "         NSWEEP is INTEGER",
       "         NSWEEP is the number of sweeps of Jacobi rotations to be",
       "         performed."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (LWORK)"],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         LWORK is the dimension of WORK. LWORK .GE. M."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0 : successful exit.",
       "         < 0 : if INFO = -i, then the i-th argument had an illegal value"]}},
 "ztpttr"=>
  {"summary"=>
    ["ZTPTTR copies a triangular matrix A from standard packed format (TP)",
     "to standard full format (TR)."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  A is upper triangular.",
       "         = 'L':  A is lower triangular."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A. N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension ( N*(N+1)/2 ),",
       "         On entry, the upper or lower triangular matrix A, packed",
       "         columnwise in a linear array. The j-th column of A is stored",
       "         in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n."],
     "A"=>
      ["[out]",
       "         A is COMPLEX*16 array, dimension ( LDA, N )",
       "         On exit, the triangular matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cposv"=>
  {"summary"=>
    ["CPOSV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N Hermitian positive definite matrix and X and B",
     "are N-by-NRHS matrices.",
     "The Cholesky decomposition is used to factor A as",
     "   A = U**H* U,  if UPLO = 'U', or",
     "   A = L * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and  L is a lower triangular",
     "matrix.  The factored form of A is then used to solve the system of",
     "equations A * X = B."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         N-by-N upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading N-by-N lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization A = U**H*U or A = L*L**H."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the N-by-NRHS right hand side matrix B.",
       "         On exit, if INFO = 0, the N-by-NRHS solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i of A is not",
       "               positive definite, so the factorization could not be",
       "               completed, and the solution has not been computed."]}},
 "cgges3"=>
  {"summary"=>
    ["CGGES3 computes for a pair of N-by-N complex nonsymmetric matrices",
     "(A,B), the generalized eigenvalues, the generalized complex Schur",
     "form (S, T), and optionally left and/or right Schur vectors (VSL",
     "and VSR). This gives the generalized Schur factorization",
     "        (A,B) = ( (VSL)*S*(VSR)**H, (VSL)*T*(VSR)**H )",
     "where (VSR)**H is the conjugate-transpose of VSR.",
     "Optionally, it also orders the eigenvalues so that a selected cluster",
     "of eigenvalues appears in the leading diagonal blocks of the upper",
     "triangular matrix S and the upper triangular matrix T. The leading",
     "columns of VSL and VSR then form an unitary basis for the",
     "corresponding left and right eigenspaces (deflating subspaces).",
     "(If only the generalized eigenvalues are needed, use the driver",
     "CGGEV instead, which is faster.)",
     "A generalized eigenvalue for a pair of matrices (A,B) is a scalar w",
     "or a ratio alpha/beta = w, such that  A - w*B is singular.  It is",
     "usually represented as the pair (alpha,beta), as there is a",
     "reasonable interpretation for beta=0, and even for both being zero.",
     "A pair of matrices (S,T) is in generalized complex Schur form if S",
     "and T are upper triangular and, in addition, the diagonal elements",
     "of T are non-negative real numbers."],
   "param"=>
    {"JOBVSL"=>
      ["[in]",
       "         JOBVSL is CHARACTER*1",
       "         = 'N':  do not compute the left Schur vectors;",
       "         = 'V':  compute the left Schur vectors."],
     "JOBVSR"=>
      ["[in]",
       "         JOBVSR is CHARACTER*1",
       "         = 'N':  do not compute the right Schur vectors;",
       "         = 'V':  compute the right Schur vectors."],
     "SORT"=>
      ["[in]",
       "         SORT is CHARACTER*1",
       "         Specifies whether or not to order the eigenvalues on the",
       "         diagonal of the generalized Schur form.",
       "         = 'N':  Eigenvalues are not ordered;",
       "         = 'S':  Eigenvalues are ordered (see SELCTG)."],
     "SELCTG"=>
      ["[in]",
       "         SELCTG is a LOGICAL FUNCTION of two COMPLEX arguments",
       "         SELCTG must be declared EXTERNAL in the calling subroutine.",
       "         If SORT = 'N', SELCTG is not referenced.",
       "         If SORT = 'S', SELCTG is used to select eigenvalues to sort",
       "         to the top left of the Schur form.",
       "         An eigenvalue ALPHA(j)/BETA(j) is selected if",
       "         SELCTG(ALPHA(j),BETA(j)) is true.",
       "         Note that a selected complex eigenvalue may no longer satisfy",
       "         SELCTG(ALPHA(j),BETA(j)) = .TRUE. after ordering, since",
       "         ordering may change the value of complex eigenvalues",
       "         (especially if the eigenvalue is ill-conditioned), in this",
       "         case INFO is set to N+2 (See INFO below)."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices A, B, VSL, and VSR.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA, N)",
       "         On entry, the first of the pair of matrices.",
       "         On exit, A has been overwritten by its generalized Schur",
       "         form S."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, the second of the pair of matrices.",
       "         On exit, B has been overwritten by its generalized Schur",
       "         form T."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of B.  LDB >= max(1,N)."],
     "SDIM"=>
      ["[out]",
       "         SDIM is INTEGER",
       "         If SORT = 'N', SDIM = 0.",
       "         If SORT = 'S', SDIM = number of eigenvalues (after sorting)",
       "         for which SELCTG is true."],
     "ALPHA"=>["[out]", "         ALPHA is COMPLEX array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is COMPLEX array, dimension (N)",
       "         On exit,  ALPHA(j)/BETA(j), j=1,...,N, will be the",
       "         generalized eigenvalues.  ALPHA(j), j=1,...,N  and  BETA(j),",
       "         j=1,...,N  are the diagonals of the complex Schur form (A,B)",
       "         output by CGGES3. The  BETA(j) will be non-negative real.",
       "         Note: the quotients ALPHA(j)/BETA(j) may easily over- or",
       "         underflow, and BETA(j) may even be zero.  Thus, the user",
       "         should avoid naively computing the ratio alpha/beta.",
       "         However, ALPHA will be always less than and usually",
       "         comparable with norm(A) in magnitude, and BETA always less",
       "         than and usually comparable with norm(B)."],
     "VSL"=>
      ["[out]",
       "         VSL is COMPLEX array, dimension (LDVSL,N)",
       "         If JOBVSL = 'V', VSL will contain the left Schur vectors.",
       "         Not referenced if JOBVSL = 'N'."],
     "LDVSL"=>
      ["[in]",
       "         LDVSL is INTEGER",
       "         The leading dimension of the matrix VSL. LDVSL >= 1, and",
       "         if JOBVSL = 'V', LDVSL >= N."],
     "VSR"=>
      ["[out]",
       "         VSR is COMPLEX array, dimension (LDVSR,N)",
       "         If JOBVSR = 'V', VSR will contain the right Schur vectors.",
       "         Not referenced if JOBVSR = 'N'."],
     "LDVSR"=>
      ["[in]",
       "         LDVSR is INTEGER",
       "         The leading dimension of the matrix VSR. LDVSR >= 1, and",
       "         if JOBVSR = 'V', LDVSR >= N."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "RWORK"=>["[out]", "         RWORK is REAL array, dimension (8*N)"],
     "BWORK"=>
      ["[out]",
       "         BWORK is LOGICAL array, dimension (N)",
       "         Not referenced if SORT = 'N'."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         =1,...,N:",
       "               The QZ iteration failed.  (A,B) are not in Schur",
       "               form, but ALPHA(j) and BETA(j) should be correct for",
       "               j=INFO+1,...,N.",
       "         > N:  =N+1: other than QZ iteration failed in CHGEQZ",
       "               =N+2: after reordering, roundoff changed values of",
       "                     some complex eigenvalues so that leading",
       "                     eigenvalues in the Generalized Schur form no",
       "                     longer satisfy SELCTG=.TRUE.  This could also",
       "                     be caused due to scaling.",
       "               =N+3: reordering failed in CTGSEN."]}},
 "spbsvx"=>
  {"summary"=>
    ["SPBSVX uses the Cholesky factorization A = U**T*U or A = L*L**T to",
     "compute the solution to a real system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N symmetric positive definite band matrix and X",
     "and B are N-by-NRHS matrices.",
     "Error bounds on the solution and a condition estimate are also",
     "provided."],
   "param"=>nil},
 "ctgsy2"=>
  {"summary"=>
    ["CTGSY2 solves the generalized Sylvester equation",
     "            A * R - L * B = scale *  C               (1)",
     "            D * R - L * E = scale * F",
     "using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices,",
     "(A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M,",
     "N-by-N and M-by-N, respectively. A, B, D and E are upper triangular",
     "(i.e., (A,D) and (B,E) in generalized Schur form).",
     "The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output",
     "scaling factor chosen to avoid overflow.",
     "In matrix notation solving equation (1) corresponds to solve",
     "Zx = scale * b, where Z is defined as",
     "       Z = [ kron(In, A)  -kron(B**H, Im) ]             (2)",
     "           [ kron(In, D)  -kron(E**H, Im) ],",
     "Ik is the identity matrix of size k and X**H is the transpose of X.",
     "kron(X, Y) is the Kronecker product between the matrices X and Y.",
     "If TRANS = 'C', y in the conjugate transposed system Z**H*y = scale*b",
     "is solved for, which is equivalent to solve for R and L in",
     "            A**H * R  + D**H * L   = scale * C           (3)",
     "            R  * B**H + L  * E**H  = scale * -F",
     "This case is used to compute an estimate of Dif[(A, D), (B, E)] =",
     "= sigma_min(Z) using reverse communicaton with CLACON.",
     "CTGSY2 also (IJOB >= 1) contributes to the computation in CTGSYL",
     "of an upper bound on the separation between to matrix pairs. Then",
     "the input (A, D), (B, E) are sub-pencils of two matrix pairs in",
     "CTGSYL."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N', solve the generalized Sylvester equation (1).",
       "         = 'T': solve the 'transposed' system (3)."],
     "IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies what kind of functionality to be performed.",
       "         =0: solve (1) only.",
       "         =1: A contribution from this subsystem to a Frobenius",
       "             norm-based estimate of the separation between two matrix",
       "             pairs is computed. (look ahead strategy is used).",
       "         =2: A contribution from this subsystem to a Frobenius",
       "             norm-based estimate of the separation between two matrix",
       "             pairs is computed. (SGECON on sub-systems is used.)",
       "         Not referenced if TRANS = 'T'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         On entry, M specifies the order of A and D, and the row",
       "         dimension of C, F, R and L."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         On entry, N specifies the order of B and E, and the column",
       "         dimension of C, F, R and L."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA, M)",
       "         On entry, A contains an upper triangular matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the matrix A. LDA >= max(1, M)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX array, dimension (LDB, N)",
       "         On entry, B contains an upper triangular matrix."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the matrix B. LDB >= max(1, N)."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX array, dimension (LDC, N)",
       "         On entry, C contains the right-hand-side of the first matrix",
       "         equation in (1).",
       "         On exit, if IJOB = 0, C has been overwritten by the solution",
       "         R."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the matrix C. LDC >= max(1, M)."],
     "D"=>
      ["[in]",
       "         D is COMPLEX array, dimension (LDD, M)",
       "         On entry, D contains an upper triangular matrix."],
     "LDD"=>
      ["[in]",
       "         LDD is INTEGER",
       "         The leading dimension of the matrix D. LDD >= max(1, M)."],
     "E"=>
      ["[in]",
       "         E is COMPLEX array, dimension (LDE, N)",
       "         On entry, E contains an upper triangular matrix."],
     "LDE"=>
      ["[in]",
       "         LDE is INTEGER",
       "         The leading dimension of the matrix E. LDE >= max(1, N)."],
     "F"=>
      ["[in,out]",
       "         F is COMPLEX array, dimension (LDF, N)",
       "         On entry, F contains the right-hand-side of the second matrix",
       "         equation in (1).",
       "         On exit, if IJOB = 0, F has been overwritten by the solution",
       "         L."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the matrix F. LDF >= max(1, M)."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         On exit, 0 <= SCALE <= 1. If 0 < SCALE < 1, the solutions",
       "         R and L (C and F on entry) will hold the solutions to a",
       "         slightly perturbed system but the input matrices A, B, D and",
       "         E have not been changed. If SCALE = 0, R and L will hold the",
       "         solutions to the homogeneous system with C = F = 0.",
       "         Normally, SCALE = 1."],
     "RDSUM"=>
      ["[in,out]",
       "         RDSUM is REAL",
       "         On entry, the sum of squares of computed contributions to",
       "         the Dif-estimate under computation by CTGSYL, where the",
       "         scaling factor RDSCAL (see below) has been factored out.",
       "         On exit, the corresponding sum of squares updated with the",
       "         contributions from the current sub-system.",
       "         If TRANS = 'T' RDSUM is not touched.",
       "         NOTE: RDSUM only makes sense when CTGSY2 is called by",
       "         CTGSYL."],
     "RDSCAL"=>
      ["[in,out]",
       "         RDSCAL is REAL",
       "         On entry, scaling factor used to prevent overflow in RDSUM.",
       "         On exit, RDSCAL is updated w.r.t. the current contributions",
       "         in RDSUM.",
       "         If TRANS = 'T', RDSCAL is not touched.",
       "         NOTE: RDSCAL only makes sense when CTGSY2 is called by",
       "         CTGSYL."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         On exit, if INFO is set to",
       "           =0: Successful exit",
       "           <0: If INFO = -i, input argument number i is illegal.",
       "           >0: The matrix pairs (A, D) and (B, E) have common or very",
       "               close eigenvalues."]}},
 "dgbsvxx"=>
  {"summary"=>
    ["   DGBSVXX uses the LU factorization to compute the solution to a",
     "   double precision system of linear equations  A * X = B,  where A is an",
     "   N-by-N matrix and X and B are N-by-NRHS matrices.",
     "   If requested, both normwise and maximum componentwise error bounds",
     "   are returned. DGBSVXX will return a solution with a tiny",
     "   guaranteed error (O(eps) where eps is the working machine",
     "   precision) unless the matrix is very ill-conditioned, in which",
     "   case a warning is returned. Relevant condition numbers also are",
     "   calculated and returned.",
     "   DGBSVXX accepts user-provided factorizations and equilibration",
     "   factors; see the definitions of the FACT and EQUED options.",
     "   Solving with refinement and using a factorization from a previous",
     "   DGBSVXX call will also produce a solution with either O(eps)",
     "   errors or warnings, but we cannot make that claim for general",
     "   user-provided factorizations and equilibration factors if they",
     "   differ from what DGBSVXX would itself produce."],
   "param"=>nil},
 "ctfsm"=>
  {"summary"=>
    ["Level 3 BLAS like routine for A in RFP Format.",
     "CTFSM solves the matrix equation",
     "   op( A )*X = alpha*B  or  X*op( A ) = alpha*B",
     "where alpha is a scalar, X and B are m by n matrices, A is a unit, or",
     "non-unit,  upper or lower triangular matrix  and  op( A )  is one  of",
     "   op( A ) = A   or   op( A ) = A**H.",
     "A is in Rectangular Full Packed (RFP) Format.",
     "The matrix X is overwritten on B."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal Form of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose Form of RFP A is stored."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "          On entry, SIDE specifies whether op( A ) appears on the left",
       "          or right of X as follows:",
       "             SIDE = 'L' or 'l'   op( A )*X = alpha*B.",
       "             SIDE = 'R' or 'r'   X*op( A ) = alpha*B.",
       "          Unchanged on exit."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "          On entry, UPLO specifies whether the RFP matrix A came from",
       "          an upper or lower triangular matrix as follows:",
       "          UPLO = 'U' or 'u' RFP A came from an upper triangular matrix",
       "          UPLO = 'L' or 'l' RFP A came from a  lower triangular matrix",
       "          Unchanged on exit."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "          On entry, TRANS  specifies the form of op( A ) to be used",
       "          in the matrix multiplication as follows:",
       "             TRANS  = 'N' or 'n'   op( A ) = A.",
       "             TRANS  = 'C' or 'c'   op( A ) = conjg( A' ).",
       "          Unchanged on exit."],
     "DIAG"=>
      ["[in]",
       "         DIAG is CHARACTER*1",
       "          On entry, DIAG specifies whether or not RFP A is unit",
       "          triangular as follows:",
       "             DIAG = 'U' or 'u'   A is assumed to be unit triangular.",
       "             DIAG = 'N' or 'n'   A is not assumed to be unit",
       "                                 triangular.",
       "          Unchanged on exit."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "          On entry, M specifies the number of rows of B. M must be at",
       "          least zero.",
       "          Unchanged on exit."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "          On entry, N specifies the number of columns of B.  N must be",
       "          at least zero.",
       "          Unchanged on exit."],
     "ALPHA"=>
      ["[in]",
       "         ALPHA is COMPLEX",
       "          On entry,  ALPHA specifies the scalar  alpha. When  alpha is",
       "          zero then  A is not referenced and  B need not be set before",
       "          entry.",
       "          Unchanged on exit."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (N*(N+1)/2)",
       "          NT = N*(N+1)/2. On entry, the matrix A in RFP Format.",
       "          RFP Format is described by TRANSR, UPLO and N as follows:",
       "          If TRANSR='N' then RFP A is (0:N,0:K-1) when N is even;",
       "          K=N/2. RFP A is (0:N-1,0:K) when N is odd; K=N/2. If",
       "          TRANSR = 'C' then RFP is the Conjugate-transpose of RFP A as",
       "          defined when TRANSR = 'N'. The contents of RFP A are defined",
       "          by UPLO as follows: If UPLO = 'U' the RFP A contains the NT",
       "          elements of upper packed A either in normal or",
       "          conjugate-transpose Format. If UPLO = 'L' the RFP A contains",
       "          the NT elements of lower packed A either in normal or",
       "          conjugate-transpose Format. The LDA of RFP A is (N+1)/2 when",
       "          TRANSR = 'C'. When TRANSR is 'N' the LDA is N+1 when N is",
       "          even and is N when is odd.",
       "          See the Note below for more details. Unchanged on exit."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,N)",
       "          Before entry,  the leading  m by n part of the array  B must",
       "          contain  the  right-hand  side  matrix  B,  and  on exit  is",
       "          overwritten by the solution matrix  X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "          On entry, LDB specifies the first dimension of B as declared",
       "          in  the  calling  (sub)  program.   LDB  must  be  at  least",
       "          max( 1, m ).",
       "          Unchanged on exit."]}},
 "dgebrd"=>
  {"summary"=>
    ["DGEBRD reduces a general real M-by-N matrix A to upper or lower",
     "bidiagonal form B by an orthogonal transformation: Q**T * A * P = B.",
     "If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows in the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns in the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N general matrix to be reduced.",
       "         On exit,",
       "         if m >= n, the diagonal and the first superdiagonal are",
       "           overwritten with the upper bidiagonal matrix B; the",
       "           elements below the diagonal, with the array TAUQ, represent",
       "           the orthogonal matrix Q as a product of elementary",
       "           reflectors, and the elements above the first superdiagonal,",
       "           with the array TAUP, represent the orthogonal matrix P as",
       "           a product of elementary reflectors;",
       "         if m < n, the diagonal and the first subdiagonal are",
       "           overwritten with the lower bidiagonal matrix B; the",
       "           elements below the first subdiagonal, with the array TAUQ,",
       "           represent the orthogonal matrix Q as a product of",
       "           elementary reflectors, and the elements above the diagonal,",
       "           with the array TAUP, represent the orthogonal matrix P as",
       "           a product of elementary reflectors.",
       "         See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "D"=>
      ["[out]",
       "         D is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The diagonal elements of the bidiagonal matrix B:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is DOUBLE PRECISION array, dimension (min(M,N)-1)",
       "         The off-diagonal elements of the bidiagonal matrix B:",
       "         if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;",
       "         if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1."],
     "TAUQ"=>
      ["[out]",
       "         TAUQ is DOUBLE PRECISION array dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Q. See Further Details."],
     "TAUP"=>
      ["[out]",
       "         TAUP is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix P. See Further Details."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The length of the array WORK.  LWORK >= max(1,M,N).",
       "         For optimum performance LWORK >= (M+N)*NB, where NB",
       "         is the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "chetd2"=>
  {"summary"=>
    ["CHETD2 reduces a complex Hermitian matrix A to real symmetric",
     "tridiagonal form T by a unitary similarity transformation:",
     "Q**H * A * Q = T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the Hermitian matrix A.  If UPLO = 'U', the leading",
       "         n-by-n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n-by-n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if UPLO = 'U', the diagonal and first superdiagonal",
       "         of A are overwritten by the corresponding elements of the",
       "         tridiagonal matrix T, and the elements above the first",
       "         superdiagonal, with the array TAU, represent the unitary",
       "         matrix Q as a product of elementary reflectors; if UPLO",
       "         = 'L', the diagonal and first subdiagonal of A are over-",
       "         written by the corresponding elements of the tridiagonal",
       "         matrix T, and the elements below the first subdiagonal, with",
       "         the array TAU, represent the unitary matrix Q as a product",
       "         of elementary reflectors. See Further Details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         The diagonal elements of the tridiagonal matrix T:",
       "         D(i) = A(i,i)."],
     "E"=>
      ["[out]",
       "         E is REAL array, dimension (N-1)",
       "         The off-diagonal elements of the tridiagonal matrix T:",
       "         E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'."],
     "TAU"=>
      ["[out]",
       "         TAU is COMPLEX array, dimension (N-1)",
       "         The scalar factors of the elementary reflectors (see Further",
       "         Details)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "zlahef_aa"=>
  {"summary"=>
    ["DLAHEF_AA factorizes a panel of a complex hermitian matrix A using",
     "the Aasen's algorithm. The panel consists of a set of NB rows of A",
     "when UPLO is U, or a set of NB columns when UPLO is L.",
     "In order to factorize the panel, the Aasen's algorithm requires the",
     "last row, or column, of the previous panel. The first row, or column,",
     "of A is set to be the first row, or column, of an identity matrix,",
     "which is used to factorize the first panel.",
     "The resulting J-th row of U, or J-th column of L, is stored in the",
     "(J-1)-th row, or column, of A (without the unit diagonals), while",
     "the diagonal and subdiagonal of A are overwritten by those of T."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "J1"=>
      ["[in]",
       "         J1 is INTEGER",
       "         The location of the first row, or column, of the panel",
       "         within the submatrix of A, passed to this routine, e.g.,",
       "         when called by ZHETRF_AA, for the first panel, J1 is 1,",
       "         while for the remaining panels, J1 is 2."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The dimension of the submatrix. M >= 0."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The dimension of the panel to be facotorized."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,M) for",
       "         the first panel, while dimension (LDA,M+1) for the",
       "         remaining panels.",
       "         On entry, A contains the last row, or column, of",
       "         the previous panel, and the trailing submatrix of A",
       "         to be factorized, except for the first panel, only",
       "         the panel is passed.",
       "         On exit, the leading panel is factorized."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the row and column interchanges,",
       "         the row and column k were interchanged with the row and",
       "         column IPIV(k)."],
     "H"=>
      ["[in,out]", "         H is COMPLEX*16 workspace, dimension (LDH,NB)."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the workspace H. LDH >= max(1,M)."],
     "WORK"=>
      ["[out]", "         WORK is COMPLEX*16 workspace, dimension (M)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, D(i,i) is exactly zero.  The factorization",
       "               has been completed, but the block diagonal matrix D is",
       "               exactly singular, and division by zero will occur if it",
       "               is used to solve a system of equations."]}},
 "checon_rook"=>
  {"summary"=>
    ["CHECON_ROOK estimates the reciprocal of the condition number of a complex",
     "Hermitian matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by CHETRF_ROOK.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CHETRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF_ROOK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is REAL",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is REAL",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "zunmbr"=>
  {"summary"=>
    ["If VECT = 'Q', ZUNMBR overwrites the general complex M-by-N matrix C",
     "with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      Q * C          C * Q",
     "TRANS = 'C':      Q**H * C       C * Q**H",
     "If VECT = 'P', ZUNMBR overwrites the general complex M-by-N matrix C",
     "with",
     "                SIDE = 'L'     SIDE = 'R'",
     "TRANS = 'N':      P * C          C * P",
     "TRANS = 'C':      P**H * C       C * P**H",
     "Here Q and P**H are the unitary matrices determined by ZGEBRD when",
     "reducing a complex matrix A to bidiagonal form: A = Q * B * P**H. Q",
     "and P**H are defined as products of elementary reflectors H(i) and",
     "G(i) respectively.",
     "Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the",
     "order of the unitary matrix Q or P**H that is applied.",
     "If VECT = 'Q', A is assumed to have been an NQ-by-K matrix:",
     "if nq >= k, Q = H(1) H(2) . . . H(k);",
     "if nq < k, Q = H(1) H(2) . . . H(nq-1).",
     "If VECT = 'P', A is assumed to have been a K-by-NQ matrix:",
     "if k < nq, P = G(1) G(2) . . . G(k);",
     "if k >= nq, P = G(1) G(2) . . . G(nq-1)."],
   "param"=>
    {"VECT"=>
      ["[in]",
       "         VECT is CHARACTER*1",
       "         = 'Q': apply Q or Q**H;",
       "         = 'P': apply P or P**H."],
     "SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply Q, Q**H, P or P**H from the Left;",
       "         = 'R': apply Q, Q**H, P or P**H from the Right."],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N':  No transpose, apply Q or P;",
       "         = 'C':  Conjugate transpose, apply Q**H or P**H."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         If VECT = 'Q', the number of columns in the original",
       "         matrix reduced by ZGEBRD.",
       "         If VECT = 'P', the number of rows in the original",
       "         matrix reduced by ZGEBRD.",
       "         K >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension",
       "                               (LDA,min(nq,K)) if VECT = 'Q'",
       "                               (LDA,nq)        if VECT = 'P'",
       "         The vectors which define the elementary reflectors H(i) and",
       "         G(i), whose products determine the matrices Q and P, as",
       "         returned by ZGEBRD."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If VECT = 'Q', LDA >= max(1,nq);",
       "         if VECT = 'P', LDA >= max(1,min(nq,K))."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX*16 array, dimension (min(nq,K))",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i) or G(i) which determines Q or P, as returned",
       "         by ZGEBRD in the array argument TAUQ or TAUP."],
     "C"=>
      ["[in,out]",
       "         C is COMPLEX*16 array, dimension (LDC,N)",
       "         On entry, the M-by-N matrix C.",
       "         On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q",
       "         or P*C or P**H*C or C*P or C*P**H."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If SIDE = 'L', LWORK >= max(1,N);",
       "         if SIDE = 'R', LWORK >= max(1,M);",
       "         if N = 0 or M = 0, LWORK >= 1.",
       "         For optimum performance LWORK >= max(1,N*NB) if SIDE = 'L',",
       "         and LWORK >= max(1,M*NB) if SIDE = 'R', where NB is the",
       "         optimal blocksize. (NB = 0 if M = 0 or N = 0.)",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dlarrj"=>
  {"summary"=>
    ["Given the initial eigenvalue approximations of T, DLARRJ",
     "does  bisection to refine the eigenvalues of T,",
     "W( IFIRST-OFFSET ) through W( ILAST-OFFSET ), to more accuracy. Initial",
     "guesses for these eigenvalues are input in W, the corresponding estimate",
     "of the error in these guesses in WERR. During bisection, intervals",
     "[left, right] are maintained by storing their mid-points and",
     "semi-widths in the arrays W and WERR respectively."],
   "param"=>
    {"N"=>
      ["[in]", "         N is INTEGER", "         The order of the matrix."],
     "D"=>
      ["[in]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "         The N diagonal elements of T."],
     "E2"=>
      ["[in]",
       "         E2 is DOUBLE PRECISION array, dimension (N-1)",
       "         The Squares of the (N-1) subdiagonal elements of T."],
     "IFIRST"=>
      ["[in]",
       "         IFIRST is INTEGER",
       "         The index of the first eigenvalue to be computed."],
     "ILAST"=>
      ["[in]",
       "         ILAST is INTEGER",
       "         The index of the last eigenvalue to be computed."],
     "RTOL"=>
      ["[in]",
       "         RTOL is DOUBLE PRECISION",
       "         Tolerance for the convergence of the bisection intervals.",
       "         An interval [LEFT,RIGHT] has converged if",
       "         RIGHT-LEFT.LT.RTOL*MAX(|LEFT|,|RIGHT|)."],
     "OFFSET"=>
      ["[in]",
       "         OFFSET is INTEGER",
       "         Offset for the arrays W and WERR, i.e., the IFIRST-OFFSET",
       "         through ILAST-OFFSET elements of these arrays are to be used."],
     "W"=>
      ["[in,out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "         On input, W( IFIRST-OFFSET ) through W( ILAST-OFFSET ) are",
       "         estimates of the eigenvalues of L D L^T indexed IFIRST through",
       "         ILAST.",
       "         On output, these estimates are refined."],
     "WERR"=>
      ["[in,out]",
       "         WERR is DOUBLE PRECISION array, dimension (N)",
       "         On input, WERR( IFIRST-OFFSET ) through WERR( ILAST-OFFSET ) are",
       "         the errors in the estimates of the corresponding elements in W.",
       "         On output, these errors are refined."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (2*N)",
       "         Workspace."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (2*N)",
       "         Workspace."],
     "PIVMIN"=>
      ["[in]",
       "         PIVMIN is DOUBLE PRECISION",
       "         The minimum pivot in the Sturm sequence for T."],
     "SPDIAM"=>
      ["[in]",
       "         SPDIAM is DOUBLE PRECISION",
       "         The spectral diameter of T."],
     "INFO"=>["[out]", "         INFO is INTEGER", "         Error flag."]}},
 "dggrqf"=>
  {"summary"=>
    ["DGGRQF computes a generalized RQ factorization of an M-by-N matrix A",
     "and a P-by-N matrix B:",
     "            A = R*Q,        B = Z*T*Q,",
     "where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal",
     "matrix, and R and T assume one of the forms:",
     "if M <= N,  R = ( 0  R12 ) M,   or if M > N,  R = ( R11 ) M-N,",
     "                 N-M  M                           ( R21 ) N",
     "                                                     N",
     "where R12 or R21 is upper triangular, and",
     "if P >= N,  T = ( T11 ) N  ,   or if P < N,  T = ( T11  T12 ) P,",
     "                (  0  ) P-N                         P   N-P",
     "                   N",
     "where T11 is upper triangular.",
     "In particular, if B is square and nonsingular, the GRQ factorization",
     "of A and B implicitly gives the RQ factorization of A*inv(B):",
     "             A*inv(B) = (R*inv(T))*Z**T",
     "where inv(B) denotes the inverse of the matrix B, and Z**T denotes the",
     "transpose of the matrix Z."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B. N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, if M <= N, the upper triangle of the subarray",
       "         A(1:M,N-M+1:N) contains the M-by-M upper triangular matrix R;",
       "         if M > N, the elements on and above the (M-N)-th subdiagonal",
       "         contain the M-by-N upper trapezoidal matrix R; the remaining",
       "         elements, with the array TAUA, represent the orthogonal",
       "         matrix Q as a product of elementary reflectors (see Further",
       "         Details)."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "TAUA"=>
      ["[out]",
       "         TAUA is DOUBLE PRECISION array, dimension (min(M,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Q (see Further Details)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the min(P,N)-by-N upper trapezoidal matrix T (T is",
       "         upper triangular if P >= N); the elements below the diagonal,",
       "         with the array TAUB, represent the orthogonal matrix Z as a",
       "         product of elementary reflectors (see Further Details)."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TAUB"=>
      ["[out]",
       "         TAUB is DOUBLE PRECISION array, dimension (min(P,N))",
       "         The scalar factors of the elementary reflectors which",
       "         represent the orthogonal matrix Z (see Further Details)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= max(1,N,M,P).",
       "         For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),",
       "         where NB1 is the optimal blocksize for the RQ factorization",
       "         of an M-by-N matrix, NB2 is the optimal blocksize for the",
       "         QR factorization of a P-by-N matrix, and NB3 is the optimal",
       "         blocksize for a call of DORMRQ.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INF0= -i, the i-th argument had an illegal value."]}},
 "chbevd"=>
  {"summary"=>
    ["CHBEVD computes all the eigenvalues and, optionally, eigenvectors of",
     "a complex Hermitian band matrix A.  If eigenvectors are desired, it",
     "uses a divide and conquer algorithm.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of superdiagonals of the matrix A if UPLO = 'U',",
       "         or the number of subdiagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB, N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, AB is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the first",
       "         superdiagonal and the diagonal of the tridiagonal matrix T",
       "         are returned in rows KD and KD+1 of AB, and if UPLO = 'L',",
       "         the diagonal and first subdiagonal of T are returned in the",
       "         first two rows of AB."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD + 1."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is COMPLEX array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK.",
       "         If N <= 1,               LWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LWORK must be at least N.",
       "         If JOBZ = 'V' and N > 1, LWORK must be at least 2*N**2.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal sizes of the WORK, RWORK and",
       "         IWORK arrays, returns these values as the first entries of",
       "         the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array,",
       "                                        dimension (LRWORK)",
       "         On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK."],
     "LRWORK"=>
      ["[in]",
       "         LRWORK is INTEGER",
       "         The dimension of array RWORK.",
       "         If N <= 1,               LRWORK must be at least 1.",
       "         If JOBZ = 'N' and N > 1, LRWORK must be at least N.",
       "         If JOBZ = 'V' and N > 1, LRWORK must be at least",
       "                       1 + 5*N + 2*N**2.",
       "         If LRWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK."],
     "LIWORK"=>
      ["[in]",
       "         LIWORK is INTEGER",
       "         The dimension of array IWORK.",
       "         If JOBZ = 'N' or N <= 1, LIWORK must be at least 1.",
       "         If JOBZ = 'V' and N > 1, LIWORK must be at least 3 + 5*N .",
       "         If LIWORK = -1, then a workspace query is assumed; the",
       "         routine only calculates the optimal sizes of the WORK, RWORK",
       "         and IWORK arrays, returns these values as the first entries",
       "         of the WORK, RWORK and IWORK arrays, and no error message",
       "         related to LWORK or LRWORK or LIWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dorghr"=>
  {"summary"=>
    ["DORGHR generates a real orthogonal matrix Q which is defined as the",
     "product of IHI-ILO elementary reflectors of order N, as returned by",
     "DGEHRD:",
     "Q = H(ilo) H(ilo+1) . . . H(ihi-1)."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix Q. N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         ILO and IHI must have the same values as in the previous call",
       "         of DGEHRD. Q is equal to the unit matrix except in the",
       "         submatrix Q(ilo+1:ihi,ilo+1:ihi).",
       "         1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the vectors which define the elementary reflectors,",
       "         as returned by DGEHRD.",
       "         On exit, the N-by-N orthogonal matrix Q."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,N)."],
     "TAU"=>
      ["[in]",
       "         TAU is DOUBLE PRECISION array, dimension (N-1)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i), as returned by DGEHRD."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK >= IHI-ILO.",
       "         For optimum performance LWORK >= (IHI-ILO)*NB, where NB is",
       "         the optimal blocksize.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "sspev"=>
  {"summary"=>
    ["SSPEV computes all the eigenvalues and, optionally, eigenvectors of a",
     "real symmetric matrix A in packed storage."],
   "param"=>
    {"JOBZ"=>
      ["[in]",
       "         JOBZ is CHARACTER*1",
       "         = 'N':  Compute eigenvalues only;",
       "         = 'V':  Compute eigenvalues and eigenvectors."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in,out]",
       "         AP is REAL array, dimension (N*(N+1)/2)",
       "         On entry, the upper or lower triangle of the symmetric matrix",
       "         A, packed columnwise in a linear array.  The j-th column of A",
       "         is stored in the array AP as follows:",
       "         if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;",
       "         if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.",
       "         On exit, AP is overwritten by values generated during the",
       "         reduction to tridiagonal form.  If UPLO = 'U', the diagonal",
       "         and first superdiagonal of the tridiagonal matrix T overwrite",
       "         the corresponding elements of A, and if UPLO = 'L', the",
       "         diagonal and first subdiagonal of T overwrite the",
       "         corresponding elements of A."],
     "W"=>
      ["[out]",
       "         W is REAL array, dimension (N)",
       "         If INFO = 0, the eigenvalues in ascending order."],
     "Z"=>
      ["[out]",
       "         Z is REAL array, dimension (LDZ, N)",
       "         If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal",
       "         eigenvectors of the matrix A, with the i-th column of Z",
       "         holding the eigenvector associated with W(i).",
       "         If JOBZ = 'N', then Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z.  LDZ >= 1, and if",
       "         JOBZ = 'V', LDZ >= max(1,N)."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (3*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = i, the algorithm failed to converge; i",
       "               off-diagonal elements of an intermediate tridiagonal",
       "               form did not converge to zero."]}},
 "dsyrfsx"=>
  {"summary"=>
    ["   DSYRFSX improves the computed solution to a system of linear",
     "   equations when the coefficient matrix is symmetric indefinite, and",
     "   provides error bounds and backward error estimates for the",
     "   solution.  In addition to normwise error bound, the code provides",
     "   maximum componentwise error bound if possible.  See comments for",
     "   ERR_BNDS_NORM and ERR_BNDS_COMP for details of the error bounds.",
     "   The original system of linear equations may have been equilibrated",
     "   before calling this routine, as described by arguments EQUED and S",
     "   below. In this case, the solution and error bounds returned are",
     "   for the original unequilibrated system.",
     "    Some optional parameters are bundled in the PARAMS array.  These",
     "    settings determine how refinement is performed, but often the",
     "    defaults are acceptable.  If the defaults are acceptable, users",
     "    can pass NPARAMS = 0 which prevents the source code from accessing",
     "    the PARAMS argument."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "EQUED"=>
      ["[in]",
       "         EQUED is CHARACTER*1",
       "    Specifies the form of equilibration that was done to A",
       "    before calling this routine. This is needed to compute",
       "    the solution and error bounds correctly.",
       "      = 'N':  No equilibration",
       "      = 'Y':  Both row and column equilibration, i.e., A has been",
       "              replaced by diag(S) * A * diag(S).",
       "              The right hand side B has been changed accordingly."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices B and X.  NRHS >= 0."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "    The symmetric matrix A.  If UPLO = 'U', the leading N-by-N",
       "    upper triangular part of A contains the upper triangular",
       "    part of the matrix A, and the strictly lower triangular",
       "    part of A is not referenced.  If UPLO = 'L', the leading",
       "    N-by-N lower triangular part of A contains the lower",
       "    triangular part of the matrix A, and the strictly upper",
       "    triangular part of A is not referenced."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is DOUBLE PRECISION array, dimension (LDAF,N)",
       "    The factored form of the matrix A.  AF contains the block",
       "    diagonal matrix D and the multipliers used to obtain the",
       "    factor U or L from the factorization A = U*D*U**T or A =",
       "    L*D*L**T as computed by DSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by DSYTRF."],
     "S"=>
      ["[in,out]",
       "         S is DOUBLE PRECISION array, dimension (N)",
       "    The scale factors for A.  If EQUED = 'Y', A is multiplied on",
       "    the left and right by diag(S).  S is an input argument if FACT =",
       "    'F'; otherwise, S is an output argument.  If FACT = 'F' and EQUED",
       "    = 'Y', each element of S must be positive.  If S is output, each",
       "    element of S is a power of the radix. If S is input, each element",
       "    of S should be a power of the radix to ensure a reliable solution",
       "    and error estimates. Scaling by powers of the radix does not cause",
       "    rounding errors unless the result underflows or overflows.",
       "    Rounding errors during scaling lead to refining with a matrix that",
       "    is not equivalent to the input matrix, producing error estimates",
       "    that may not be reliable."],
     "B"=>
      ["[in]",
       "         B is DOUBLE PRECISION array, dimension (LDB,NRHS)",
       "    The right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "    The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension (LDX,NRHS)",
       "    On entry, the solution matrix X, as computed by DGETRS.",
       "    On exit, the improved solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "    The leading dimension of the array X.  LDX >= max(1,N)."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "    Reciprocal scaled condition number.  This is an estimate of the",
       "    reciprocal Skeel condition number of the matrix A after",
       "    equilibration (if done).  If this is less than the machine",
       "    precision (in particular, if it is zero), the matrix is singular",
       "    to working precision.  Note that the error may still be small even",
       "    if this number is very small and the matrix appears ill-",
       "    conditioned."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "    Componentwise relative backward error.  This is the",
       "    componentwise relative backward error of each solution vector X(j)",
       "    (i.e., the smallest relative change in any element of A or B that",
       "    makes X(j) an exact solution)."],
     "N_ERR_BNDS"=>
      ["[in]",
       "         N_ERR_BNDS is INTEGER",
       "    Number of error bounds to return for each right hand side",
       "    and each type (normwise or componentwise).  See ERR_BNDS_NORM and",
       "    ERR_BNDS_COMP below."],
     "ERR_BNDS_NORM"=>
      ["[out]",
       "         ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    normwise relative error, which is defined as follows:",
       "    Normwise relative error in the ith solution vector:",
       "            max_j (abs(XTRUE(j,i) - X(j,i)))",
       "           ------------------------------",
       "                 max_j abs(X(j,i))",
       "    The array is indexed by the type of error information as described",
       "    below. There currently are up to three pieces of information",
       "    returned.",
       "    The first index in ERR_BNDS_NORM(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_NORM(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated normwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*A, where S scales each row by a power of the",
       "             radix so all absolute row sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "ERR_BNDS_COMP"=>
      ["[out]",
       "         ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)",
       "    For each right-hand side, this array contains information about",
       "    various error bounds and condition numbers corresponding to the",
       "    componentwise relative error, which is defined as follows:",
       "    Componentwise relative error in the ith solution vector:",
       "                   abs(XTRUE(j,i) - X(j,i))",
       "            max_j ----------------------",
       "                        abs(X(j,i))",
       "    The array is indexed by the right-hand side i (on which the",
       "    componentwise relative error depends), and the type of error",
       "    information as described below. There currently are up to three",
       "    pieces of information returned for each right-hand side. If",
       "    componentwise accuracy is not requested (PARAMS(3) = 0.0), then",
       "    ERR_BNDS_COMP is not accessed.  If N_ERR_BNDS .LT. 3, then at most",
       "    the first (:,N_ERR_BNDS) entries are returned.",
       "    The first index in ERR_BNDS_COMP(i,:) corresponds to the ith",
       "    right-hand side.",
       "    The second index in ERR_BNDS_COMP(:,err) contains the following",
       "    three fields:",
       "    err = 1 \"Trust/don't trust\" boolean. Trust the answer if the",
       "             reciprocal condition number is less than the threshold",
       "             sqrt(n) * dlamch('Epsilon').",
       "    err = 2 \"Guaranteed\" error bound: The estimated forward error,",
       "             almost certainly within a factor of 10 of the true error",
       "             so long as the next entry is greater than the threshold",
       "             sqrt(n) * dlamch('Epsilon'). This error bound should only",
       "             be trusted if the previous boolean is true.",
       "    err = 3  Reciprocal condition number: Estimated componentwise",
       "             reciprocal condition number.  Compared with the threshold",
       "             sqrt(n) * dlamch('Epsilon') to determine if the error",
       "             estimate is \"guaranteed\". These reciprocal condition",
       "             numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some",
       "             appropriately scaled matrix Z.",
       "             Let Z = S*(A*diag(x)), where x is the solution for the",
       "             current right-hand side and S scales each row of",
       "             A*diag(x) by a power of the radix so all absolute row",
       "             sums of Z are approximately 1.",
       "    See Lapack Working Note 165 for further details and extra",
       "    cautions."],
     "NPARAMS"=>
      ["[in]",
       "         NPARAMS is INTEGER",
       "    Specifies the number of parameters set in PARAMS.  If .LE. 0, the",
       "    PARAMS array is never referenced and default values are used."],
     "PARAMS"=>
      ["[in,out]",
       "         PARAMS is DOUBLE PRECISION array, dimension (NPARAMS)",
       "    Specifies algorithm parameters.  If an entry is .LT. 0.0, then",
       "    that entry will be filled with default value used for that",
       "    parameter.  Only positions up to NPARAMS are accessed; defaults",
       "    are used for higher-numbered parameters.",
       "      PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative",
       "           refinement or not.",
       "        Default: 1.0D+0",
       "           = 0.0 : No refinement is performed, and no error bounds are",
       "                   computed.",
       "           = 1.0 : Use the double-precision refinement algorithm,",
       "                   possibly with doubled-single computations if the",
       "                   compilation environment does not support DOUBLE",
       "                   PRECISION.",
       "             (other values are reserved for future use)",
       "      PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual",
       "           computations allowed for refinement.",
       "        Default: 10",
       "        Aggressive: Set to 100 to permit convergence using approximate",
       "                    factorizations or factorizations other than LU. If",
       "                    the factorization uses a technique other than",
       "                    Gaussian elimination, the guarantees in",
       "                    err_bnds_norm and err_bnds_comp may no longer be",
       "                    trustworthy.",
       "      PARAMS(LA_LINRX_CWISE_I = 3) : Flag determining if the code",
       "           will attempt to find a solution with small componentwise",
       "           relative error in the double-precision algorithm.  Positive",
       "           is true, 0.0 is false.",
       "        Default: 1.0 (attempt componentwise convergence)"],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (4*N)"],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit. The solution to every right-hand side is",
       "        guaranteed.",
       "      < 0:  If INFO = -i, the i-th argument had an illegal value",
       "      > 0 and <= N:  U(INFO,INFO) is exactly zero.  The factorization",
       "        has been completed, but the factor U is exactly singular, so",
       "        the solution and error bounds could not be computed. RCOND = 0",
       "        is returned.",
       "      = N+J: The solution corresponding to the Jth right-hand side is",
       "        not guaranteed. The solutions corresponding to other right-",
       "        hand sides K with K > J may not be guaranteed as well, but",
       "        only the first such right-hand side is reported. If a small",
       "        componentwise error is not requested (PARAMS(3) = 0.0) then",
       "        the Jth right-hand side is the first with a normwise error",
       "        bound that is not guaranteed (the smallest J such",
       "        that ERR_BNDS_NORM(J,1) = 0.0). By default (PARAMS(3) = 1.0)",
       "        the Jth right-hand side is the first with either a normwise or",
       "        componentwise error bound that is not guaranteed (the smallest",
       "        J such that either ERR_BNDS_NORM(J,1) = 0.0 or",
       "        ERR_BNDS_COMP(J,1) = 0.0). See the definition of",
       "        ERR_BNDS_NORM(:,1) and ERR_BNDS_COMP(:,1). To get information",
       "        about all of the right-hand sides check ERR_BNDS_NORM or",
       "        ERR_BNDS_COMP."]}},
 "slaic1"=>
  {"summary"=>
    ["SLAIC1 applies one step of incremental condition estimation in",
     "its simplest version:",
     "Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j",
     "lower triangular matrix L, such that",
     "         twonorm(L*x) = sest",
     "Then SLAIC1 computes sestpr, s, c such that",
     "the vector",
     "                [ s*x ]",
     "         xhat = [  c  ]",
     "is an approximate singular vector of",
     "                [ L      0  ]",
     "         Lhat = [ w**T gamma ]",
     "in the sense that",
     "         twonorm(Lhat*xhat) = sestpr.",
     "Depending on JOB, an estimate for the largest or smallest singular",
     "value is computed.",
     "Note that [s c]**T and sestpr**2 is an eigenpair of the system",
     "    diag(sest*sest, 0) + [alpha  gamma] * [ alpha ]",
     "                                          [ gamma ]",
     "where  alpha =  x**T*w."],
   "param"=>
    {"JOB"=>
      ["[in]",
       "         JOB is INTEGER",
       "         = 1: an estimate for the largest singular value is computed.",
       "         = 2: an estimate for the smallest singular value is computed."],
     "J"=>["[in]", "         J is INTEGER", "         Length of X and W"],
     "X"=>
      ["[in]",
       "         X is REAL array, dimension (J)",
       "         The j-vector x."],
     "SEST"=>
      ["[in]",
       "         SEST is REAL",
       "         Estimated singular value of j by j matrix L"],
     "W"=>
      ["[in]",
       "         W is REAL array, dimension (J)",
       "         The j-vector w."],
     "GAMMA"=>
      ["[in]",
       "         GAMMA is REAL",
       "         The diagonal element gamma."],
     "SESTPR"=>
      ["[out]",
       "         SESTPR is REAL",
       "         Estimated singular value of (j+1) by (j+1) matrix Lhat."],
     "S"=>
      ["[out]", "         S is REAL", "         Sine needed in forming xhat."],
     "C"=>
      ["[out]",
       "         C is REAL",
       "         Cosine needed in forming xhat."]}},
 "cpbtf2"=>
  {"summary"=>
    ["CPBTF2 computes the Cholesky factorization of a complex Hermitian",
     "positive definite band matrix A.",
     "The factorization has the form",
     "   A = U**H * U ,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix, U**H is the conjugate transpose",
     "of U, and L is lower triangular.",
     "This is the unblocked version of the algorithm, calling Level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         Hermitian matrix A is stored:",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "KD"=>
      ["[in]",
       "         KD is INTEGER",
       "         The number of super-diagonals of the matrix A if UPLO = 'U',",
       "         or the number of sub-diagonals if UPLO = 'L'.  KD >= 0."],
     "AB"=>
      ["[in,out]",
       "         AB is COMPLEX array, dimension (LDAB,N)",
       "         On entry, the upper or lower triangle of the Hermitian band",
       "         matrix A, stored in the first KD+1 rows of the array.  The",
       "         j-th column of A is stored in the j-th column of the array AB",
       "         as follows:",
       "         if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;",
       "         if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).",
       "         On exit, if INFO = 0, the triangular factor U or L from the",
       "         Cholesky factorization A = U**H *U or A = L*L**H of the band",
       "         matrix A, in the same storage format as A."],
     "LDAB"=>
      ["[in]",
       "         LDAB is INTEGER",
       "         The leading dimension of the array AB.  LDAB >= KD+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -k, the k-th argument had an illegal value",
       "         > 0: if INFO = k, the leading minor of order k is not",
       "              positive definite, and the factorization could not be",
       "              completed."]}},
 "zhecon_rook"=>
  {"summary"=>
    ["ZHECON_ROOK estimates the reciprocal of the condition number of a complex",
     "Hermitian matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by CHETRF_ROOK.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by CHETRF_ROOK."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by CHETRF_ROOK."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "ztpqrt"=>
  {"summary"=>
    ["ZTPQRT computes a blocked QR factorization of a complex",
     "\"triangular-pentagonal\" matrix C, which is composed of a",
     "triangular block A and pentagonal block B, using the compact",
     "WY representation for Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix B.",
       "         M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix B, and the order of the",
       "         triangular matrix A.",
       "         N >= 0."],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         The number of rows of the upper trapezoidal part of B.",
       "         MIN(M,N) >= L >= 0.  See Further Details."],
     "NB"=>
      ["[in]",
       "         NB is INTEGER",
       "         The block size to be used in the blocked QR.  N >= NB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the upper triangular N-by-N matrix A.",
       "         On exit, the elements on and above the diagonal of the array",
       "         contain the upper triangular matrix R."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,N)",
       "         On entry, the pentagonal M-by-N matrix B.  The first M-L rows",
       "         are rectangular, and the last L rows are upper trapezoidal.",
       "         On exit, B contains the pentagonal matrix V.  See Further Details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX*16 array, dimension (LDT,N)",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See Further Details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= NB."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (NB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cla_porcond_x"=>
  {"summary"=>
    ["   CLA_PORCOND_X Computes the infinity norm condition number of",
     "   op(A) * diag(X) where X is a COMPLEX vector."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The triangular factor U or L from the Cholesky factorization",
       "    A = U**H*U or A = L*L**H, as computed by CPOTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "X"=>
      ["[in]",
       "         X is COMPLEX array, dimension (N)",
       "    The vector X in the formula op(A) * diag(X)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is REAL array, dimension (N).",
       "    Workspace."]}},
 "dlarfgp"=>
  {"summary"=>
    ["DLARFGP generates a real elementary reflector H of order n, such",
     "that",
     "      H * ( alpha ) = ( beta ),   H**T * H = I.",
     "          (   x   )   (   0  )",
     "where alpha and beta are scalars, beta is non-negative, and x is",
     "an (n-1)-element real vector.  H is represented in the form",
     "      H = I - tau * ( 1 ) * ( 1 v**T ) ,",
     "                    ( v )",
     "where tau is a real scalar and v is a real (n-1)-element",
     "vector.",
     "If the elements of x are all zero, then tau = 0 and H is taken to be",
     "the unit matrix."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the elementary reflector."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is DOUBLE PRECISION",
       "         On entry, the value alpha.",
       "         On exit, it is overwritten with the value beta."],
     "X"=>
      ["[in,out]",
       "         X is DOUBLE PRECISION array, dimension",
       "                        (1+(N-2)*abs(INCX))",
       "         On entry, the vector x.",
       "         On exit, it is overwritten with the vector v."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "TAU"=>
      ["[out]",
       "         TAU is DOUBLE PRECISION",
       "         The value tau."]}},
 "slarfgp"=>
  {"summary"=>
    ["SLARFGP generates a real elementary reflector H of order n, such",
     "that",
     "      H * ( alpha ) = ( beta ),   H**T * H = I.",
     "          (   x   )   (   0  )",
     "where alpha and beta are scalars, beta is non-negative, and x is",
     "an (n-1)-element real vector.  H is represented in the form",
     "      H = I - tau * ( 1 ) * ( 1 v**T ) ,",
     "                    ( v )",
     "where tau is a real scalar and v is a real (n-1)-element",
     "vector.",
     "If the elements of x are all zero, then tau = 0 and H is taken to be",
     "the unit matrix."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the elementary reflector."],
     "ALPHA"=>
      ["[in,out]",
       "         ALPHA is REAL",
       "         On entry, the value alpha.",
       "         On exit, it is overwritten with the value beta."],
     "X"=>
      ["[in,out]",
       "         X is REAL array, dimension",
       "                        (1+(N-2)*abs(INCX))",
       "         On entry, the vector x.",
       "         On exit, it is overwritten with the vector v."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The increment between elements of X. INCX > 0."],
     "TAU"=>["[out]", "         TAU is REAL", "         The value tau."]}},
 "zhptrs"=>
  {"summary"=>
    ["ZHPTRS solves a system of linear equations A*X = B with a complex",
     "Hermitian matrix A stored in packed format using the factorization",
     "A = U*D*U**H or A = L*D*L**H computed by ZHPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZHPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHPTRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "iladlc"=>
  {"summary"=>["ILADLC scans A for its last non-zero column."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A."],
     "A"=>
      ["[in]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The m by n matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."]}},
 "zpstf2"=>
  {"summary"=>
    ["ZPSTF2 computes the Cholesky factorization with complete",
     "pivoting of a complex Hermitian positive semidefinite matrix A.",
     "The factorization has the form",
     "   P**T * A * P = U**H * U ,  if UPLO = 'U',",
     "   P**T * A * P = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular, and",
     "P is stored as vector PIV.",
     "This algorithm does not attempt to check that A is positive",
     "semidefinite. This version of the algorithm calls level 2 BLAS."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the upper or lower triangular part of the",
       "         symmetric matrix A is stored.",
       "         = 'U':  Upper triangular",
       "         = 'L':  Lower triangular"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the symmetric matrix A.  If UPLO = 'U', the leading",
       "         n by n upper triangular part of A contains the upper",
       "         triangular part of the matrix A, and the strictly lower",
       "         triangular part of A is not referenced.  If UPLO = 'L', the",
       "         leading n by n lower triangular part of A contains the lower",
       "         triangular part of the matrix A, and the strictly upper",
       "         triangular part of A is not referenced.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization as above."],
     "PIV"=>
      ["[out]",
       "         PIV is INTEGER array, dimension (N)",
       "         PIV is such that the nonzero entries are P( PIV(K), K ) = 1."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The rank of A given by the number of steps the algorithm",
       "         completed."],
     "TOL"=>
      ["[in]",
       "         TOL is DOUBLE PRECISION",
       "         User defined tolerance. If TOL < 0, then N*U*MAX( A( K,K ) )",
       "         will be used. The algorithm terminates at the (K-1)st step",
       "         if the pivot <= TOL."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (2*N)",
       "         Work space."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         < 0: If INFO = -K, the K-th argument had an illegal value,",
       "         = 0: algorithm completed successfully, and",
       "         > 0: the matrix A is either rank deficient with computed rank",
       "              as returned in RANK, or is not positive semidefinite. See",
       "              Section 7 of LAPACK Working Note #161 for further",
       "              information."]}},
 "sgelqt"=>
  {"summary"=>
    ["DGELQT computes a blocked LQ factorization of a real M-by-N matrix A",
     "using the compact WY representation of Q."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "MB"=>
      ["[in]",
       "         MB is INTEGER",
       "         The block size to be used in the blocked QR.  MIN(M,N) >= MB >= 1."],
     "A"=>
      ["[in,out]",
       "         A is REAL array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, the elements on and below the diagonal of the array",
       "         contain the M-by-MIN(M,N) lower trapezoidal matrix L (L is",
       "         lower triangular if M <= N); the elements above the diagonal",
       "         are the rows of V."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,M)."],
     "T"=>
      ["[out]",
       "         T is REAL array, dimension (LDT,MIN(M,N))",
       "         The upper triangular block reflectors stored in compact form",
       "         as a sequence of upper triangular blocks.  See below",
       "         for further details."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T.  LDT >= MB."],
     "WORK"=>["[out]", "         WORK is REAL array, dimension (MB*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "cla_syrcond_c"=>
  {"summary"=>
    ["   CLA_SYRCOND_C Computes the infinity norm condition number of",
     "   op(A) * inv(diag(C)) where C is a REAL vector."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "      = 'U':  Upper triangle of A is stored;",
       "      = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "A"=>
      ["[in]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "    On entry, the N-by-N matrix A"],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "    The leading dimension of the array A.  LDA >= max(1,N)."],
     "AF"=>
      ["[in]",
       "         AF is COMPLEX array, dimension (LDAF,N)",
       "    The block diagonal matrix D and the multipliers used to",
       "    obtain the factor U or L as computed by CSYTRF."],
     "LDAF"=>
      ["[in]",
       "         LDAF is INTEGER",
       "    The leading dimension of the array AF.  LDAF >= max(1,N)."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "    Details of the interchanges and the block structure of D",
       "    as determined by CSYTRF."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "    The vector C in the formula op(A) * inv(diag(C))."],
     "CAPPLY"=>
      ["[in]",
       "         CAPPLY is LOGICAL",
       "    If .TRUE. then access the vector C in the formula above."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "      = 0:  Successful exit.",
       "    i > 0:  The ith argument is invalid."],
     "WORK"=>
      ["[in]",
       "         WORK is COMPLEX array, dimension (2*N).",
       "    Workspace."],
     "RWORK"=>
      ["[in]",
       "         RWORK is REAL array, dimension (N).",
       "    Workspace."]}},
 "slahqr"=>
  {"summary"=>
    ["   SLAHQR is an auxiliary routine called by SHSEQR to update the",
     "   eigenvalues and Schur decomposition already computed by SHSEQR, by",
     "   dealing with the Hessenberg submatrix in rows and columns ILO to",
     "   IHI."],
   "param"=>
    {"WANTT"=>
      ["[in]",
       "         WANTT is LOGICAL",
       "         = .TRUE. : the full Schur form T is required;",
       "         = .FALSE.: only eigenvalues are required."],
     "WANTZ"=>
      ["[in]",
       "         WANTZ is LOGICAL",
       "         = .TRUE. : the matrix of Schur vectors Z is required;",
       "         = .FALSE.: Schur vectors are not required."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix H.  N >= 0."],
     "ILO"=>["[in]", "         ILO is INTEGER"],
     "IHI"=>
      ["[in]",
       "         IHI is INTEGER",
       "         It is assumed that H is already upper quasi-triangular in",
       "         rows and columns IHI+1:N, and that H(ILO,ILO-1) = 0 (unless",
       "         ILO = 1). SLAHQR works primarily with the Hessenberg",
       "         submatrix in rows and columns ILO to IHI, but applies",
       "         transformations to all of H if WANTT is .TRUE..",
       "         1 <= ILO <= max(1,IHI); IHI <= N."],
     "H"=>
      ["[in,out]",
       "         H is REAL array, dimension (LDH,N)",
       "         On entry, the upper Hessenberg matrix H.",
       "         On exit, if INFO is zero and if WANTT is .TRUE., H is upper",
       "         quasi-triangular in rows and columns ILO:IHI, with any",
       "         2-by-2 diagonal blocks in standard form. If INFO is zero",
       "         and WANTT is .FALSE., the contents of H are unspecified on",
       "         exit.  The output state of H if INFO is nonzero is given",
       "         below under the description of INFO."],
     "LDH"=>
      ["[in]",
       "         LDH is INTEGER",
       "         The leading dimension of the array H. LDH >= max(1,N)."],
     "WR"=>["[out]", "         WR is REAL array, dimension (N)"],
     "WI"=>
      ["[out]",
       "         WI is REAL array, dimension (N)",
       "         The real and imaginary parts, respectively, of the computed",
       "         eigenvalues ILO to IHI are stored in the corresponding",
       "         elements of WR and WI. If two eigenvalues are computed as a",
       "         complex conjugate pair, they are stored in consecutive",
       "         elements of WR and WI, say the i-th and (i+1)th, with",
       "         WI(i) > 0 and WI(i+1) < 0. If WANTT is .TRUE., the",
       "         eigenvalues are stored in the same order as on the diagonal",
       "         of the Schur form returned in H, with WR(i) = H(i,i), and, if",
       "         H(i:i+1,i:i+1) is a 2-by-2 diagonal block,",
       "         WI(i) = sqrt(H(i+1,i)*H(i,i+1)) and WI(i+1) = -WI(i)."],
     "ILOZ"=>["[in]", "         ILOZ is INTEGER"],
     "IHIZ"=>
      ["[in]",
       "         IHIZ is INTEGER",
       "         Specify the rows of Z to which transformations must be",
       "         applied if WANTZ is .TRUE..",
       "         1 <= ILOZ <= ILO; IHI <= IHIZ <= N."],
     "Z"=>
      ["[in,out]",
       "         Z is REAL array, dimension (LDZ,N)",
       "         If WANTZ is .TRUE., on entry Z must contain the current",
       "         matrix Z of transformations accumulated by SHSEQR, and on",
       "         exit Z has been updated; transformations are applied only to",
       "         the submatrix Z(ILOZ:IHIZ,ILO:IHI).",
       "         If WANTZ is .FALSE., Z is not referenced."],
     "LDZ"=>
      ["[in]",
       "         LDZ is INTEGER",
       "         The leading dimension of the array Z. LDZ >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "          =   0: successful exit",
       "         .GT. 0: If INFO = i, SLAHQR failed to compute all the",
       "                 eigenvalues ILO to IHI in a total of 30 iterations",
       "                 per eigenvalue; elements i+1:ihi of WR and WI",
       "                 contain those eigenvalues which have been",
       "                 successfully computed.",
       "                 If INFO .GT. 0 and WANTT is .FALSE., then on exit,",
       "                 the remaining unconverged eigenvalues are the",
       "                 eigenvalues of the upper Hessenberg matrix rows",
       "                 and columns ILO thorugh INFO of the final, output",
       "                 value of H.",
       "                 If INFO .GT. 0 and WANTT is .TRUE., then on exit",
       "         (*)       (initial value of H)*U  = U*(final value of H)",
       "                 where U is an orthognal matrix.    The final",
       "                 value of H is upper Hessenberg and triangular in",
       "                 rows and columns INFO+1 through IHI.",
       "                 If INFO .GT. 0 and WANTZ is .TRUE., then on exit",
       "                     (final value of Z)  = (initial value of Z)*U",
       "                 where U is the orthogonal matrix in (*)",
       "                 (regardless of the value of WANTT.)"]}},
 "dlartgp"=>
  {"summary"=>
    ["DLARTGP generates a plane rotation so that",
     "   [  CS  SN  ]  .  [ F ]  =  [ R ]   where CS**2 + SN**2 = 1.",
     "   [ -SN  CS  ]     [ G ]     [ 0 ]",
     "This is a slower, more accurate version of the Level 1 BLAS routine DROTG,",
     "with the following other differences:",
     "   F and G are unchanged on return.",
     "   If G=0, then CS=(+/-)1 and SN=0.",
     "   If F=0 and (G .ne. 0), then CS=0 and SN=(+/-)1.",
     "The sign is chosen so that R >= 0."],
   "param"=>
    {"F"=>
      ["[in]",
       "         F is DOUBLE PRECISION",
       "         The first component of vector to be rotated."],
     "G"=>
      ["[in]",
       "         G is DOUBLE PRECISION",
       "         The second component of vector to be rotated."],
     "CS"=>
      ["[out]",
       "         CS is DOUBLE PRECISION",
       "         The cosine of the rotation."],
     "SN"=>
      ["[out]",
       "         SN is DOUBLE PRECISION",
       "         The sine of the rotation."],
     "R"=>
      ["[out]",
       "         R is DOUBLE PRECISION",
       "         The nonzero component of the rotated vector.",
       " This version has a few statements commented out for thread safety",
       " (machine parameters are computed on each entry). 10 feb 03, SJH."]}},
 "claqge"=>
  {"summary"=>
    ["CLAQGE equilibrates a general M by N matrix A using the row and",
     "column scaling factors in the vectors R and C."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M by N matrix A.",
       "         On exit, the equilibrated matrix.  See EQUED for the form of",
       "         the equilibrated matrix."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(M,1)."],
     "R"=>
      ["[in]",
       "         R is REAL array, dimension (M)",
       "         The row scale factors for A."],
     "C"=>
      ["[in]",
       "         C is REAL array, dimension (N)",
       "         The column scale factors for A."],
     "ROWCND"=>
      ["[in]",
       "         ROWCND is REAL",
       "         Ratio of the smallest R(i) to the largest R(i)."],
     "COLCND"=>
      ["[in]",
       "         COLCND is REAL",
       "         Ratio of the smallest C(i) to the largest C(i)."],
     "AMAX"=>
      ["[in]",
       "         AMAX is REAL",
       "         Absolute value of largest matrix entry."],
     "EQUED"=>
      ["[out]",
       "         EQUED is CHARACTER*1",
       "         Specifies the form of equilibration that was done.",
       "         = 'N':  No equilibration",
       "         = 'R':  Row equilibration, i.e., A has been premultiplied by",
       "                 diag(R).",
       "         = 'C':  Column equilibration, i.e., A has been postmultiplied",
       "                 by diag(C).",
       "         = 'B':  Both row and column equilibration, i.e., A has been",
       "                 replaced by diag(R) * A * diag(C)."]}},
 "dlascl"=>
  {"summary"=>
    ["DLASCL multiplies the M by N real matrix A by the real scalar",
     "CTO/CFROM.  This is done without over/underflow as long as the final",
     "result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that",
     "A may be full, upper triangular, lower triangular, upper Hessenberg,",
     "or banded."],
   "param"=>
    {"TYPE"=>
      ["[in]",
       "         TYPE is CHARACTER*1",
       "         TYPE indices the storage type of the input matrix.",
       "         = 'G':  A is a full matrix.",
       "         = 'L':  A is a lower triangular matrix.",
       "         = 'U':  A is an upper triangular matrix.",
       "         = 'H':  A is an upper Hessenberg matrix.",
       "         = 'B':  A is a symmetric band matrix with lower bandwidth KL",
       "                 and upper bandwidth KU and with the only the lower",
       "                 half stored.",
       "         = 'Q':  A is a symmetric band matrix with lower bandwidth KL",
       "                 and upper bandwidth KU and with the only the upper",
       "                 half stored.",
       "         = 'Z':  A is a band matrix with lower bandwidth KL and upper",
       "                 bandwidth KU. See DGBTRF for storage details."],
     "KL"=>
      ["[in]",
       "         KL is INTEGER",
       "         The lower bandwidth of A.  Referenced only if TYPE = 'B',",
       "         'Q' or 'Z'."],
     "KU"=>
      ["[in]",
       "         KU is INTEGER",
       "         The upper bandwidth of A.  Referenced only if TYPE = 'B',",
       "         'Q' or 'Z'."],
     "CFROM"=>["[in]", "         CFROM is DOUBLE PRECISION"],
     "CTO"=>
      ["[in]",
       "         CTO is DOUBLE PRECISION",
       "         The matrix A is multiplied by CTO/CFROM. A(I,J) is computed",
       "         without over/underflow if the final result CTO*A(I,J)/CFROM",
       "         can be represented without over/underflow.  CFROM must be",
       "         nonzero."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         The matrix to be multiplied by CTO/CFROM.  See TYPE for the",
       "         storage type."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.",
       "         If TYPE = 'G', 'L', 'U', 'H', LDA >= max(1,M);",
       "            TYPE = 'B', LDA >= KL+1;",
       "            TYPE = 'Q', LDA >= KU+1;",
       "            TYPE = 'Z', LDA >= 2*KL+KU+1."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         0  - successful exit",
       "         <0 - if INFO = -i, the i-th argument had an illegal value."]}},
 "dlarfb"=>
  {"summary"=>
    ["DLARFB applies a real block reflector H or its transpose H**T to a",
     "real m by n matrix C, from either the left or the right."],
   "param"=>
    {"SIDE"=>
      ["[in]",
       "         SIDE is CHARACTER*1",
       "         = 'L': apply H or H**T from the Left",
       "         = 'R': apply H or H**T from the Right"],
     "TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N': apply H (No transpose)",
       "         = 'T': apply H**T (Transpose)"],
     "DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Indicates how H is formed from a product of elementary",
       "         reflectors",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Indicates how the vectors which define the elementary",
       "         reflectors are stored:",
       "         = 'C': Columnwise",
       "         = 'R': Rowwise"],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix C."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix C."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the matrix T (= the number of elementary",
       "         reflectors whose product defines the block reflector)."],
     "V"=>
      ["[in]",
       "         V is DOUBLE PRECISION array, dimension",
       "                               (LDV,K) if STOREV = 'C'",
       "                               (LDV,M) if STOREV = 'R' and SIDE = 'L'",
       "                               (LDV,N) if STOREV = 'R' and SIDE = 'R'",
       "         The matrix V. See Further Details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);",
       "         if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);",
       "         if STOREV = 'R', LDV >= K."],
     "T"=>
      ["[in]",
       "         T is DOUBLE PRECISION array, dimension (LDT,K)",
       "         The triangular k by k matrix T in the representation of the",
       "         block reflector."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."],
     "C"=>
      ["[in,out]",
       "         C is DOUBLE PRECISION array, dimension (LDC,N)",
       "         On entry, the m by n matrix C.",
       "         On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1,M)."],
     "WORK"=>
      ["[out]",
       "         WORK is DOUBLE PRECISION array, dimension (LDWORK,K)"],
     "LDWORK"=>
      ["[in]",
       "         LDWORK is INTEGER",
       "         The leading dimension of the array WORK.",
       "         If SIDE = 'L', LDWORK >= max(1,N);",
       "         if SIDE = 'R', LDWORK >= max(1,M)."]}},
 "cgelsd"=>
  {"summary"=>
    ["CGELSD computes the minimum-norm solution to a real linear least",
     "squares problem:",
     "    minimize 2-norm(| b - A*x |)",
     "using the singular value decomposition (SVD) of A. A is an M-by-N",
     "matrix which may be rank-deficient.",
     "Several right hand side vectors b and solution vectors x can be",
     "handled in a single call; they are stored as the columns of the",
     "M-by-NRHS right hand side matrix B and the N-by-NRHS solution",
     "matrix X.",
     "The problem is solved in three steps:",
     "(1) Reduce the coefficient matrix A to bidiagonal form with",
     "    Householder transformations, reducing the original problem",
     "    into a \"bidiagonal least squares problem\" (BLS)",
     "(2) Solve the BLS using a divide and conquer approach.",
     "(3) Apply back all the Householder transformations to solve",
     "    the original least squares problem.",
     "The effective rank of A is determined by treating as zero those",
     "singular values which are less than RCOND times the largest singular",
     "value.",
     "The divide and conquer algorithm makes very mild assumptions about",
     "floating point arithmetic. It will work on machines with a guard",
     "digit in add/subtract, or on those binary machines without guard",
     "digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or",
     "Cray-2. It could conceivably fail on hexadecimal or decimal machines",
     "without guard digits, but we know of none."],
   "param"=>
    {"M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A. M >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrix A. N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrices B and X. NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A has been destroyed."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX array, dimension (LDB,NRHS)",
       "         On entry, the M-by-NRHS right hand side matrix B.",
       "         On exit, B is overwritten by the N-by-NRHS solution matrix X.",
       "         If m >= n and RANK = n, the residual sum-of-squares for",
       "         the solution in the i-th column is given by the sum of",
       "         squares of the modulus of elements n+1:m in that column."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,M,N)."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (min(M,N))",
       "         The singular values of A in decreasing order.",
       "         The condition number of A in the 2-norm = S(1)/S(min(m,n))."],
     "RCOND"=>
      ["[in]",
       "         RCOND is REAL",
       "         RCOND is used to determine the effective rank of A.",
       "         Singular values S(i) <= RCOND*S(1) are treated as zero.",
       "         If RCOND < 0, machine precision is used instead."],
     "RANK"=>
      ["[out]",
       "         RANK is INTEGER",
       "         The effective rank of A, i.e., the number of singular values",
       "         which are greater than RCOND*S(1)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK must be at least 1.",
       "         The exact minimum amount of workspace needed depends on M,",
       "         N and NRHS. As long as LWORK is at least",
       "             2 * N + N * NRHS",
       "         if M is greater than or equal to N or",
       "             2 * M + M * NRHS",
       "         if M is less than N, the code will execute correctly.",
       "         For good performance, LWORK should generally be larger.",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the array WORK and the",
       "         minimum sizes of the arrays RWORK and IWORK, and returns",
       "         these values as the first entries of the WORK, RWORK and",
       "         IWORK arrays, and no error message related to LWORK is issued",
       "         by XERBLA."],
     "RWORK"=>
      ["[out]",
       "         RWORK is REAL array, dimension (MAX(1,LRWORK))",
       "         LRWORK >=",
       "            10*N + 2*N*SMLSIZ + 8*N*NLVL + 3*SMLSIZ*NRHS +",
       "            MAX( (SMLSIZ+1)**2, N*(1+NRHS) + 2*NRHS )",
       "         if M is greater than or equal to N or",
       "            10*M + 2*M*SMLSIZ + 8*M*NLVL + 3*SMLSIZ*NRHS +",
       "            MAX( (SMLSIZ+1)**2, N*(1+NRHS) + 2*NRHS )",
       "         if M is less than N, the code will execute correctly.",
       "         SMLSIZ is returned by ILAENV and is equal to the maximum",
       "         size of the subproblems at the bottom of the computation",
       "         tree (usually about 25), and",
       "            NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 )",
       "         On exit, if INFO = 0, RWORK(1) returns the minimum LRWORK."],
     "IWORK"=>
      ["[out]",
       "         IWORK is INTEGER array, dimension (MAX(1,LIWORK))",
       "         LIWORK >= max(1, 3*MINMN*NLVL + 11*MINMN),",
       "         where MINMN = MIN( M,N ).",
       "         On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0: successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  the algorithm for computing the SVD failed to converge;",
       "               if INFO = i, i off-diagonal elements of an intermediate",
       "               bidiagonal form did not converge to zero."]}},
 "zsptrs"=>
  {"summary"=>
    ["ZSPTRS solves a system of linear equations A*X = B with a complex",
     "symmetric matrix A stored in packed format using the factorization",
     "A = U*D*U**T or A = L*D*L**T computed by ZSPTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**T;",
       "         = 'L':  Lower triangular, form is A = L*D*L**T."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZSPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZSPTRF."],
     "B"=>
      ["[in,out]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         On entry, the right hand side matrix B.",
       "         On exit, the solution matrix X."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0: if INFO = -i, the i-th argument had an illegal value"]}},
 "zpotri"=>
  {"summary"=>
    ["ZPOTRI computes the inverse of a complex Hermitian positive definite",
     "matrix A using the Cholesky factorization A = U**H*U or A = L*L**H",
     "computed by ZPOTRF."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of A is stored;",
       "         = 'L':  Lower triangle of A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array, dimension (LDA,N)",
       "         On entry, the triangular factor U or L from the Cholesky",
       "         factorization A = U**H*U or A = L*L**H, as computed by",
       "         ZPOTRF.",
       "         On exit, the upper or lower triangle of the (Hermitian)",
       "         inverse of A, overwriting the input factor U or L."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the (i,i) element of the factor U or L is",
       "               zero, and the inverse could not be computed."]}},
 "zhpcon"=>
  {"summary"=>
    ["ZHPCON estimates the reciprocal of the condition number of a complex",
     "Hermitian packed matrix A using the factorization A = U*D*U**H or",
     "A = L*D*L**H computed by ZHPTRF.",
     "An estimate is obtained for norm(inv(A)), and the reciprocal of the",
     "condition number is computed as RCOND = 1 / (ANORM * norm(inv(A)))."],
   "param"=>
    {"UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         Specifies whether the details of the factorization are stored",
       "         as an upper or lower triangular matrix.",
       "         = 'U':  Upper triangular, form is A = U*D*U**H;",
       "         = 'L':  Lower triangular, form is A = L*D*L**H."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "AP"=>
      ["[in]",
       "         AP is COMPLEX*16 array, dimension (N*(N+1)/2)",
       "         The block diagonal matrix D and the multipliers used to",
       "         obtain the factor U or L as computed by ZHPTRF, stored as a",
       "         packed triangular matrix."],
     "IPIV"=>
      ["[in]",
       "         IPIV is INTEGER array, dimension (N)",
       "         Details of the interchanges and the block structure of D",
       "         as determined by ZHPTRF."],
     "ANORM"=>
      ["[in]",
       "         ANORM is DOUBLE PRECISION",
       "         The 1-norm of the original matrix A."],
     "RCOND"=>
      ["[out]",
       "         RCOND is DOUBLE PRECISION",
       "         The reciprocal of the condition number of the matrix A,",
       "         computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an",
       "         estimate of the 1-norm of inv(A) computed in this routine."],
     "WORK"=>["[out]", "         WORK is COMPLEX*16 array, dimension (2*N)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value"]}},
 "dtgsja"=>
  {"summary"=>
    ["DTGSJA computes the generalized singular value decomposition (GSVD)",
     "of two real upper triangular (or trapezoidal) matrices A and B.",
     "On entry, it is assumed that matrices A and B have the following",
     "forms, which may be obtained by the preprocessing subroutine DGGSVP",
     "from a general M-by-N matrix A and P-by-N matrix B:",
     "             N-K-L  K    L",
     "   A =    K ( 0    A12  A13 ) if M-K-L >= 0;",
     "          L ( 0     0   A23 )",
     "      M-K-L ( 0     0    0  )",
     "           N-K-L  K    L",
     "   A =  K ( 0    A12  A13 ) if M-K-L < 0;",
     "      M-K ( 0     0   A23 )",
     "           N-K-L  K    L",
     "   B =  L ( 0     0   B13 )",
     "      P-L ( 0     0    0  )",
     "where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular",
     "upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,",
     "otherwise A23 is (M-K)-by-L upper trapezoidal.",
     "On exit,",
     "       U**T *A*Q = D1*( 0 R ),    V**T *B*Q = D2*( 0 R ),",
     "where U, V and Q are orthogonal matrices.",
     "R is a nonsingular upper triangular matrix, and D1 and D2 are",
     "``diagonal'' matrices, which are of the following structures:",
     "If M-K-L >= 0,",
     "                    K  L",
     "       D1 =     K ( I  0 )",
     "                L ( 0  C )",
     "            M-K-L ( 0  0 )",
     "                  K  L",
     "       D2 = L   ( 0  S )",
     "            P-L ( 0  0 )",
     "               N-K-L  K    L",
     "  ( 0 R ) = K (  0   R11  R12 ) K",
     "            L (  0    0   R22 ) L",
     "where",
     "  C = diag( ALPHA(K+1), ... , ALPHA(K+L) ),",
     "  S = diag( BETA(K+1),  ... , BETA(K+L) ),",
     "  C**2 + S**2 = I.",
     "  R is stored in A(1:K+L,N-K-L+1:N) on exit.",
     "If M-K-L < 0,",
     "               K M-K K+L-M",
     "    D1 =   K ( I  0    0   )",
     "         M-K ( 0  C    0   )",
     "                 K M-K K+L-M",
     "    D2 =   M-K ( 0  S    0   )",
     "         K+L-M ( 0  0    I   )",
     "           P-L ( 0  0    0   )",
     "               N-K-L  K   M-K  K+L-M",
     "( 0 R ) =    K ( 0    R11  R12  R13  )",
     "          M-K ( 0     0   R22  R23  )",
     "        K+L-M ( 0     0    0   R33  )",
     "where",
     "C = diag( ALPHA(K+1), ... , ALPHA(M) ),",
     "S = diag( BETA(K+1),  ... , BETA(M) ),",
     "C**2 + S**2 = I.",
     "R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored",
     "    (  0  R22 R23 )",
     "in B(M-K+1:L,N+M-K-L+1:N) on exit.",
     "The computation of the orthogonal transformation matrices U, V or Q",
     "is optional.  These matrices may either be formed explicitly, or they",
     "may be postmultiplied into input matrices U1, V1, or Q1."],
   "param"=>
    {"JOBU"=>
      ["[in]",
       "         JOBU is CHARACTER*1",
       "         = 'U':  U must contain an orthogonal matrix U1 on entry, and",
       "                 the product U1*U is returned;",
       "         = 'I':  U is initialized to the unit matrix, and the",
       "                 orthogonal matrix U is returned;",
       "         = 'N':  U is not computed."],
     "JOBV"=>
      ["[in]",
       "         JOBV is CHARACTER*1",
       "         = 'V':  V must contain an orthogonal matrix V1 on entry, and",
       "                 the product V1*V is returned;",
       "         = 'I':  V is initialized to the unit matrix, and the",
       "                 orthogonal matrix V is returned;",
       "         = 'N':  V is not computed."],
     "JOBQ"=>
      ["[in]",
       "         JOBQ is CHARACTER*1",
       "         = 'Q':  Q must contain an orthogonal matrix Q1 on entry, and",
       "                 the product Q1*Q is returned;",
       "         = 'I':  Q is initialized to the unit matrix, and the",
       "                 orthogonal matrix Q is returned;",
       "         = 'N':  Q is not computed."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The number of rows of the matrix A.  M >= 0."],
     "P"=>
      ["[in]",
       "         P is INTEGER",
       "         The number of rows of the matrix B.  P >= 0."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of columns of the matrices A and B.  N >= 0."],
     "K"=>["[in]", "         K is INTEGER"],
     "L"=>
      ["[in]",
       "         L is INTEGER",
       "         K and L specify the subblocks in the input matrices A and B:",
       "         A23 = A(K+1:MIN(K+L,M),N-L+1:N) and B13 = B(1:L,N-L+1:N)",
       "         of A and B, whose GSVD is going to be computed by DTGSJA.",
       "         See Further Details."],
     "A"=>
      ["[in,out]",
       "         A is DOUBLE PRECISION array, dimension (LDA,N)",
       "         On entry, the M-by-N matrix A.",
       "         On exit, A(N-K+1:N,1:MIN(K+L,M) ) contains the triangular",
       "         matrix R or part of R.  See Purpose for details."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1,M)."],
     "B"=>
      ["[in,out]",
       "         B is DOUBLE PRECISION array, dimension (LDB,N)",
       "         On entry, the P-by-N matrix B.",
       "         On exit, if necessary, B(M-K+1:L,N+M-K-L+1:N) contains",
       "         a part of R.  See Purpose for details."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1,P)."],
     "TOLA"=>["[in]", "         TOLA is DOUBLE PRECISION"],
     "TOLB"=>
      ["[in]",
       "         TOLB is DOUBLE PRECISION",
       "         TOLA and TOLB are the convergence criteria for the Jacobi-",
       "         Kogbetliantz iteration procedure. Generally, they are the",
       "         same as used in the preprocessing step, say",
       "             TOLA = max(M,N)*norm(A)*MAZHEPS,",
       "             TOLB = max(P,N)*norm(B)*MAZHEPS."],
     "ALPHA"=>
      ["[out]", "         ALPHA is DOUBLE PRECISION array, dimension (N)"],
     "BETA"=>
      ["[out]",
       "         BETA is DOUBLE PRECISION array, dimension (N)",
       "         On exit, ALPHA and BETA contain the generalized singular",
       "         value pairs of A and B;",
       "           ALPHA(1:K) = 1,",
       "           BETA(1:K)  = 0,",
       "         and if M-K-L >= 0,",
       "           ALPHA(K+1:K+L) = diag(C),",
       "           BETA(K+1:K+L)  = diag(S),",
       "         or if M-K-L < 0,",
       "           ALPHA(K+1:M)= C, ALPHA(M+1:K+L)= 0",
       "           BETA(K+1:M) = S, BETA(M+1:K+L) = 1.",
       "         Furthermore, if K+L < N,",
       "           ALPHA(K+L+1:N) = 0 and",
       "           BETA(K+L+1:N)  = 0."],
     "U"=>
      ["[in,out]",
       "         U is DOUBLE PRECISION array, dimension (LDU,M)",
       "         On entry, if JOBU = 'U', U must contain a matrix U1 (usually",
       "         the orthogonal matrix returned by DGGSVP).",
       "         On exit,",
       "         if JOBU = 'I', U contains the orthogonal matrix U;",
       "         if JOBU = 'U', U contains the product U1*U.",
       "         If JOBU = 'N', U is not referenced."],
     "LDU"=>
      ["[in]",
       "         LDU is INTEGER",
       "         The leading dimension of the array U. LDU >= max(1,M) if",
       "         JOBU = 'U'; LDU >= 1 otherwise."],
     "V"=>
      ["[in,out]",
       "         V is DOUBLE PRECISION array, dimension (LDV,P)",
       "         On entry, if JOBV = 'V', V must contain a matrix V1 (usually",
       "         the orthogonal matrix returned by DGGSVP).",
       "         On exit,",
       "         if JOBV = 'I', V contains the orthogonal matrix V;",
       "         if JOBV = 'V', V contains the product V1*V.",
       "         If JOBV = 'N', V is not referenced."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V. LDV >= max(1,P) if",
       "         JOBV = 'V'; LDV >= 1 otherwise."],
     "Q"=>
      ["[in,out]",
       "         Q is DOUBLE PRECISION array, dimension (LDQ,N)",
       "         On entry, if JOBQ = 'Q', Q must contain a matrix Q1 (usually",
       "         the orthogonal matrix returned by DGGSVP).",
       "         On exit,",
       "         if JOBQ = 'I', Q contains the orthogonal matrix Q;",
       "         if JOBQ = 'Q', Q contains the product Q1*Q.",
       "         If JOBQ = 'N', Q is not referenced."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q. LDQ >= max(1,N) if",
       "         JOBQ = 'Q'; LDQ >= 1 otherwise."],
     "WORK"=>
      ["[out]", "         WORK is DOUBLE PRECISION array, dimension (2*N)"],
     "NCYCLE"=>
      ["[out]",
       "         NCYCLE is INTEGER",
       "         The number of cycles required for convergence."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         = 1:  the procedure does not converge after MAXIT cycles.",
       " Internal Parameters",
       " ===================",
       " MAXIT   INTEGER",
       "         MAXIT specifies the total loops that the iterative procedure",
       "         may take. If after MAXIT cycles, the routine fails to",
       "         converge, we return INFO = 1."]}},
 "zla_lin_berr"=>
  {"summary"=>
    ["   ZLA_LIN_BERR computes componentwise relative backward error from",
     "   the formula",
     "       max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )",
     "   where abs(Z) is the componentwise absolute value of the matrix",
     "   or vector Z."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "    The number of linear equations, i.e., the order of the",
       "    matrix A.  N >= 0."],
     "NZ"=>
      ["[in]",
       "         NZ is INTEGER",
       "    We add (NZ+1)*SLAMCH( 'Safe minimum' ) to R(i) in the numerator to",
       "    guard against spuriously zero residuals. Default value is N."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "    The number of right hand sides, i.e., the number of columns",
       "    of the matrices AYB, RES, and BERR.  NRHS >= 0."],
     "RES"=>
      ["[in]",
       "         RES is COMPLEX*16 array, dimension (N,NRHS)",
       "    The residual matrix, i.e., the matrix R in the relative backward",
       "    error formula above."],
     "AYB"=>
      ["[in]",
       "         AYB is DOUBLE PRECISION array, dimension (N, NRHS)",
       "    The denominator in the relative backward error formula above, i.e.,",
       "    the matrix abs(op(A_s))*abs(Y) + abs(B_s). The matrices A, Y, and B",
       "    are from iterative refinement (see zla_gerfsx_extended.f)."],
     "BERR"=>
      ["[out]",
       "         BERR is DOUBLE PRECISION array, dimension (NRHS)",
       "    The componentwise relative backward error from the formula above."]}},
 "zcgesv"=>
  {"summary"=>
    ["ZCGESV computes the solution to a complex system of linear equations",
     "   A * X = B,",
     "where A is an N-by-N matrix and X and B are N-by-NRHS matrices.",
     "ZCGESV first attempts to factorize the matrix in COMPLEX and use this",
     "factorization within an iterative refinement procedure to produce a",
     "solution with COMPLEX*16 normwise backward error quality (see below).",
     "If the approach fails the method switches to a COMPLEX*16",
     "factorization and solve.",
     "The iterative refinement is not going to be a winning strategy if",
     "the ratio COMPLEX performance over COMPLEX*16 performance is too",
     "small. A reasonable strategy should take the number of right-hand",
     "sides and the size of the matrix into account. This might be done",
     "with a call to ILAENV in the future. Up to now, we always try",
     "iterative refinement.",
     "The iterative refinement process is stopped if",
     "    ITER > ITERMAX",
     "or for all the RHS we have:",
     "    RNRM < SQRT(N)*XNRM*ANRM*EPS*BWDMAX",
     "where",
     "    o ITER is the number of the current iteration in the iterative",
     "      refinement process",
     "    o RNRM is the infinity-norm of the residual",
     "    o XNRM is the infinity-norm of the solution",
     "    o ANRM is the infinity-operator-norm of the matrix A",
     "    o EPS is the machine epsilon returned by DLAMCH('Epsilon')",
     "The value ITERMAX and BWDMAX are fixed to 30 and 1.0D+00",
     "respectively."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of linear equations, i.e., the order of the",
       "         matrix A.  N >= 0."],
     "NRHS"=>
      ["[in]",
       "         NRHS is INTEGER",
       "         The number of right hand sides, i.e., the number of columns",
       "         of the matrix B.  NRHS >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX*16 array,",
       "         dimension (LDA,N)",
       "         On entry, the N-by-N coefficient matrix A.",
       "         On exit, if iterative refinement has been successfully used",
       "         (INFO.EQ.0 and ITER.GE.0, see description below), then A is",
       "         unchanged, if double precision factorization has been used",
       "         (INFO.EQ.0 and ITER.LT.0, see description below), then the",
       "         array A contains the factors L and U from the factorization",
       "         A = P*L*U; the unit diagonal elements of L are not stored."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A.  LDA >= max(1,N)."],
     "IPIV"=>
      ["[out]",
       "         IPIV is INTEGER array, dimension (N)",
       "         The pivot indices that define the permutation matrix P;",
       "         row i of the matrix was interchanged with row IPIV(i).",
       "         Corresponds either to the single precision factorization",
       "         (if INFO.EQ.0 and ITER.GE.0) or the double precision",
       "         factorization (if INFO.EQ.0 and ITER.LT.0)."],
     "B"=>
      ["[in]",
       "         B is COMPLEX*16 array, dimension (LDB,NRHS)",
       "         The N-by-NRHS right hand side matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B.  LDB >= max(1,N)."],
     "X"=>
      ["[out]",
       "         X is COMPLEX*16 array, dimension (LDX,NRHS)",
       "         If INFO = 0, the N-by-NRHS solution matrix X."],
     "LDX"=>
      ["[in]",
       "         LDX is INTEGER",
       "         The leading dimension of the array X.  LDX >= max(1,N)."],
     "WORK"=>
      ["[out]",
       "         WORK is COMPLEX*16 array, dimension (N*NRHS)",
       "         This array is used to hold the residual vectors."],
     "SWORK"=>
      ["[out]",
       "         SWORK is COMPLEX array, dimension (N*(N+NRHS))",
       "         This array is used to use the single precision matrix and the",
       "         right-hand sides or solutions in single precision."],
     "RWORK"=>
      ["[out]", "         RWORK is DOUBLE PRECISION array, dimension (N)"],
     "ITER"=>
      ["[out]",
       "         ITER is INTEGER",
       "         < 0: iterative refinement has failed, COMPLEX*16",
       "              factorization has been performed",
       "              -1 : the routine fell back to full precision for",
       "                   implementation- or machine-specific reasons",
       "              -2 : narrowing the precision induced an overflow,",
       "                   the routine fell back to full precision",
       "              -3 : failure of CGETRF",
       "              -31: stop the iterative refinement after the 30th",
       "                   iterations",
       "         > 0: iterative refinement has been successfully used.",
       "              Returns the number of iterations"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, U(i,i) computed in COMPLEX*16 is exactly",
       "               zero.  The factorization has been completed, but the",
       "               factor U is exactly singular, so the solution",
       "               could not be computed."]}},
 "clarzt"=>
  {"summary"=>
    ["CLARZT forms the triangular factor T of a complex block reflector",
     "H of order > n, which is defined as a product of k elementary",
     "reflectors.",
     "If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;",
     "If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.",
     "If STOREV = 'C', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th column of the array V, and",
     "   H  =  I - V * T * V**H",
     "If STOREV = 'R', the vector which defines the elementary reflector",
     "H(i) is stored in the i-th row of the array V, and",
     "   H  =  I - V**H * T * V",
     "Currently, only STOREV = 'R' and DIRECT = 'B' are supported."],
   "param"=>
    {"DIRECT"=>
      ["[in]",
       "         DIRECT is CHARACTER*1",
       "         Specifies the order in which the elementary reflectors are",
       "         multiplied to form the block reflector:",
       "         = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)",
       "         = 'B': H = H(k) . . . H(2) H(1) (Backward)"],
     "STOREV"=>
      ["[in]",
       "         STOREV is CHARACTER*1",
       "         Specifies how the vectors which define the elementary",
       "         reflectors are stored (see also Further Details):",
       "         = 'C': columnwise                        (not supported yet)",
       "         = 'R': rowwise"],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the block reflector H. N >= 0."],
     "K"=>
      ["[in]",
       "         K is INTEGER",
       "         The order of the triangular factor T (= the number of",
       "         elementary reflectors). K >= 1."],
     "V"=>
      ["[in,out]",
       "         V is COMPLEX array, dimension",
       "                              (LDV,K) if STOREV = 'C'",
       "                              (LDV,N) if STOREV = 'R'",
       "         The matrix V. See further details."],
     "LDV"=>
      ["[in]",
       "         LDV is INTEGER",
       "         The leading dimension of the array V.",
       "         If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K."],
     "TAU"=>
      ["[in]",
       "         TAU is COMPLEX array, dimension (K)",
       "         TAU(i) must contain the scalar factor of the elementary",
       "         reflector H(i)."],
     "T"=>
      ["[out]",
       "         T is COMPLEX array, dimension (LDT,K)",
       "         The k by k triangular factor T of the block reflector.",
       "         If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is",
       "         lower triangular. The rest of the array is not used."],
     "LDT"=>
      ["[in]",
       "         LDT is INTEGER",
       "         The leading dimension of the array T. LDT >= K."]}},
 "izmax1"=>
  {"summary"=>
    ["IZMAX1 finds the index of the first vector element of maximum absolute value.",
     "Based on IZAMAX from Level 1 BLAS.",
     "The change is to use the 'genuine' absolute value."],
   "param"=>
    {"N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of elements in the vector ZX."],
     "ZX"=>
      ["[in]",
       "         ZX is COMPLEX*16 array, dimension (N)",
       "         The vector ZX. The IZMAX1 function returns the index of its first",
       "         element of maximum absolute value."],
     "INCX"=>
      ["[in]",
       "         INCX is INTEGER",
       "         The spacing between successive values of ZX.  INCX >= 1."]}},
 "stgsyl"=>
  {"summary"=>
    ["STGSYL solves the generalized Sylvester equation:",
     "            A * R - L * B = scale * C                 (1)",
     "            D * R - L * E = scale * F",
     "where R and L are unknown m-by-n matrices, (A, D), (B, E) and",
     "(C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n,",
     "respectively, with real entries. (A, D) and (B, E) must be in",
     "generalized (real) Schur canonical form, i.e. A, B are upper quasi",
     "triangular and D, E are upper triangular.",
     "The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output",
     "scaling factor chosen to avoid overflow.",
     "In matrix notation (1) is equivalent to solve  Zx = scale b, where",
     "Z is defined as",
     "           Z = [ kron(In, A)  -kron(B**T, Im) ]         (2)",
     "               [ kron(In, D)  -kron(E**T, Im) ].",
     "Here Ik is the identity matrix of size k and X**T is the transpose of",
     "X. kron(X, Y) is the Kronecker product between the matrices X and Y.",
     "If TRANS = 'T', STGSYL solves the transposed system Z**T*y = scale*b,",
     "which is equivalent to solve for R and L in",
     "            A**T * R + D**T * L = scale * C           (3)",
     "            R * B**T + L * E**T = scale * -F",
     "This case (TRANS = 'T') is used to compute an one-norm-based estimate",
     "of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D)",
     "and (B,E), using SLACON.",
     "If IJOB >= 1, STGSYL computes a Frobenius norm-based estimate",
     "of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the",
     "reciprocal of the smallest singular value of Z. See [1-2] for more",
     "information.",
     "This is a level 3 BLAS algorithm."],
   "param"=>
    {"TRANS"=>
      ["[in]",
       "         TRANS is CHARACTER*1",
       "         = 'N', solve the generalized Sylvester equation (1).",
       "         = 'T', solve the 'transposed' system (3)."],
     "IJOB"=>
      ["[in]",
       "         IJOB is INTEGER",
       "         Specifies what kind of functionality to be performed.",
       "          =0: solve (1) only.",
       "          =1: The functionality of 0 and 3.",
       "          =2: The functionality of 0 and 4.",
       "          =3: Only an estimate of Dif[(A,D), (B,E)] is computed.",
       "              (look ahead strategy IJOB  = 1 is used).",
       "          =4: Only an estimate of Dif[(A,D), (B,E)] is computed.",
       "              ( SGECON on sub-systems is used ).",
       "         Not referenced if TRANS = 'T'."],
     "M"=>
      ["[in]",
       "         M is INTEGER",
       "         The order of the matrices A and D, and the row dimension of",
       "         the matrices C, F, R and L."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrices B and E, and the column dimension",
       "         of the matrices C, F, R and L."],
     "A"=>
      ["[in]",
       "         A is REAL array, dimension (LDA, M)",
       "         The upper quasi triangular matrix A."],
     "LDA"=>
      ["[in]",
       "         LDA is INTEGER",
       "         The leading dimension of the array A. LDA >= max(1, M)."],
     "B"=>
      ["[in]",
       "         B is REAL array, dimension (LDB, N)",
       "         The upper quasi triangular matrix B."],
     "LDB"=>
      ["[in]",
       "         LDB is INTEGER",
       "         The leading dimension of the array B. LDB >= max(1, N)."],
     "C"=>
      ["[in,out]",
       "         C is REAL array, dimension (LDC, N)",
       "         On entry, C contains the right-hand-side of the first matrix",
       "         equation in (1) or (3).",
       "         On exit, if IJOB = 0, 1 or 2, C has been overwritten by",
       "         the solution R. If IJOB = 3 or 4 and TRANS = 'N', C holds R,",
       "         the solution achieved during the computation of the",
       "         Dif-estimate."],
     "LDC"=>
      ["[in]",
       "         LDC is INTEGER",
       "         The leading dimension of the array C. LDC >= max(1, M)."],
     "D"=>
      ["[in]",
       "         D is REAL array, dimension (LDD, M)",
       "         The upper triangular matrix D."],
     "LDD"=>
      ["[in]",
       "         LDD is INTEGER",
       "         The leading dimension of the array D. LDD >= max(1, M)."],
     "E"=>
      ["[in]",
       "         E is REAL array, dimension (LDE, N)",
       "         The upper triangular matrix E."],
     "LDE"=>
      ["[in]",
       "         LDE is INTEGER",
       "         The leading dimension of the array E. LDE >= max(1, N)."],
     "F"=>
      ["[in,out]",
       "         F is REAL array, dimension (LDF, N)",
       "         On entry, F contains the right-hand-side of the second matrix",
       "         equation in (1) or (3).",
       "         On exit, if IJOB = 0, 1 or 2, F has been overwritten by",
       "         the solution L. If IJOB = 3 or 4 and TRANS = 'N', F holds L,",
       "         the solution achieved during the computation of the",
       "         Dif-estimate."],
     "LDF"=>
      ["[in]",
       "         LDF is INTEGER",
       "         The leading dimension of the array F. LDF >= max(1, M)."],
     "DIF"=>
      ["[out]",
       "         DIF is REAL",
       "         On exit DIF is the reciprocal of a lower bound of the",
       "         reciprocal of the Dif-function, i.e. DIF is an upper bound of",
       "         Dif[(A,D), (B,E)] = sigma_min(Z), where Z as in (2).",
       "         IF IJOB = 0 or TRANS = 'T', DIF is not touched."],
     "SCALE"=>
      ["[out]",
       "         SCALE is REAL",
       "         On exit SCALE is the scaling factor in (1) or (3).",
       "         If 0 < SCALE < 1, C and F hold the solutions R and L, resp.,",
       "         to a slightly perturbed system but the input matrices A, B, D",
       "         and E have not been changed. If SCALE = 0, C and F hold the",
       "         solutions R and L, respectively, to the homogeneous system",
       "         with C = F = 0. Normally, SCALE = 1."],
     "WORK"=>
      ["[out]",
       "         WORK is REAL array, dimension (MAX(1,LWORK))",
       "         On exit, if INFO = 0, WORK(1) returns the optimal LWORK."],
     "LWORK"=>
      ["[in]",
       "         LWORK is INTEGER",
       "         The dimension of the array WORK. LWORK > = 1.",
       "         If IJOB = 1 or 2 and TRANS = 'N', LWORK >= max(1,2*M*N).",
       "         If LWORK = -1, then a workspace query is assumed; the routine",
       "         only calculates the optimal size of the WORK array, returns",
       "         this value as the first entry of the WORK array, and no error",
       "         message related to LWORK is issued by XERBLA."],
     "IWORK"=>["[out]", "         IWORK is INTEGER array, dimension (M+N+6)"],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "           =0: successful exit",
       "           <0: If INFO = -i, the i-th argument had an illegal value.",
       "           >0: (A, D) and (B, E) have common or close eigenvalues."]}},
 "cpftrf"=>
  {"summary"=>
    ["CPFTRF computes the Cholesky factorization of a complex Hermitian",
     "positive definite matrix A.",
     "The factorization has the form",
     "   A = U**H * U,  if UPLO = 'U', or",
     "   A = L  * L**H,  if UPLO = 'L',",
     "where U is an upper triangular matrix and L is lower triangular.",
     "This is the block version of the algorithm, calling Level 3 BLAS."],
   "param"=>
    {"TRANSR"=>
      ["[in]",
       "         TRANSR is CHARACTER*1",
       "         = 'N':  The Normal TRANSR of RFP A is stored;",
       "         = 'C':  The Conjugate-transpose TRANSR of RFP A is stored."],
     "UPLO"=>
      ["[in]",
       "         UPLO is CHARACTER*1",
       "         = 'U':  Upper triangle of RFP A is stored;",
       "         = 'L':  Lower triangle of RFP A is stored."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The order of the matrix A.  N >= 0."],
     "A"=>
      ["[in,out]",
       "         A is COMPLEX array, dimension ( N*(N+1)/2 );",
       "         On entry, the Hermitian matrix A in RFP format. RFP format is",
       "         described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'",
       "         then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is",
       "         (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'C' then RFP is",
       "         the Conjugate-transpose of RFP A as defined when",
       "         TRANSR = 'N'. The contents of RFP A are defined by UPLO as",
       "         follows: If UPLO = 'U' the RFP A contains the nt elements of",
       "         upper packed A. If UPLO = 'L' the RFP A contains the elements",
       "         of lower packed A. The LDA of RFP A is (N+1)/2 when TRANSR =",
       "         'C'. When TRANSR is 'N' the LDA is N+1 when N is even and N",
       "         is odd. See the Note below for more details.",
       "         On exit, if INFO = 0, the factor U or L from the Cholesky",
       "         factorization RFP A = U**H*U or RFP A = L*L**H."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value",
       "         > 0:  if INFO = i, the leading minor of order i is not",
       "               positive definite, and the factorization could not be",
       "               completed.",
       " Further Notes on RFP Format:",
       " ============================",
       " We first consider Standard Packed Format when N is even.",
       " We give an example where N = 6.",
       "    AP is Upper             AP is Lower",
       "  00 01 02 03 04 05       00",
       "     11 12 13 14 15       10 11",
       "        22 23 24 25       20 21 22",
       "           33 34 35       30 31 32 33",
       "              44 45       40 41 42 43 44",
       "                 55       50 51 52 53 54 55",
       " Let TRANSR = 'N'. RFP holds AP as follows:",
       " For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last",
       " three columns of AP upper. The lower triangle A(4:6,0:2) consists of",
       " conjugate-transpose of the first three columns of AP upper.",
       " For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first",
       " three columns of AP lower. The upper triangle A(0:2,0:2) consists of",
       " conjugate-transpose of the last three columns of AP lower.",
       " To denote conjugate we place -- above the element. This covers the",
       " case N even and TRANSR = 'N'.",
       "        RFP A                   RFP A",
       "                               -- -- --",
       "       03 04 05                33 43 53",
       "                                  -- --",
       "       13 14 15                00 44 54",
       "                                     --",
       "       23 24 25                10 11 55",
       "       33 34 35                20 21 22",
       "       --",
       "       00 44 45                30 31 32",
       "       -- --",
       "       01 11 55                40 41 42",
       "       -- -- --",
       "       02 12 22                50 51 52",
       " Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-",
       " transpose of RFP A above. One therefore gets:",
       "          RFP A                   RFP A",
       "    -- -- -- --                -- -- -- -- -- --",
       "    03 13 23 33 00 01 02    33 00 10 20 30 40 50",
       "    -- -- -- -- --                -- -- -- -- --",
       "    04 14 24 34 44 11 12    43 44 11 21 31 41 51",
       "    -- -- -- -- -- --                -- -- -- --",
       "    05 15 25 35 45 55 22    53 54 55 22 32 42 52",
       " We next  consider Standard Packed Format when N is odd.",
       " We give an example where N = 5.",
       "    AP is Upper                 AP is Lower",
       "  00 01 02 03 04              00",
       "     11 12 13 14              10 11",
       "        22 23 24              20 21 22",
       "           33 34              30 31 32 33",
       "              44              40 41 42 43 44",
       " Let TRANSR = 'N'. RFP holds AP as follows:",
       " For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last",
       " three columns of AP upper. The lower triangle A(3:4,0:1) consists of",
       " conjugate-transpose of the first two   columns of AP upper.",
       " For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first",
       " three columns of AP lower. The upper triangle A(0:1,1:2) consists of",
       " conjugate-transpose of the last two   columns of AP lower.",
       " To denote conjugate we place -- above the element. This covers the",
       " case N odd  and TRANSR = 'N'.",
       "        RFP A                   RFP A",
       "                                  -- --",
       "       02 03 04                00 33 43",
       "                                     --",
       "       12 13 14                10 11 44",
       "       22 23 24                20 21 22",
       "       --",
       "       00 33 34                30 31 32",
       "       -- --",
       "       01 11 44                40 41 42",
       " Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-",
       " transpose of RFP A above. One therefore gets:",
       "          RFP A                   RFP A",
       "    -- -- --                   -- -- -- -- -- --",
       "    02 12 22 00 01             00 10 20 30 40 50",
       "    -- -- -- --                   -- -- -- -- --",
       "    03 13 23 33 11             33 11 21 31 41 51",
       "    -- -- -- -- --                   -- -- -- --",
       "    04 14 24 34 44             43 44 22 32 42 52"]}},
 "zlaed8"=>
  {"summary"=>
    ["ZLAED8 merges the two sets of eigenvalues together into a single",
     "sorted set.  Then it tries to deflate the size of the problem.",
     "There are two ways in which deflation can occur:  when two or more",
     "eigenvalues are close together or if there is a tiny element in the",
     "Z vector.  For each such occurrence the order of the related secular",
     "equation problem is reduced by one."],
   "param"=>
    {"K"=>
      ["[out]",
       "         K is INTEGER",
       "        Contains the number of non-deflated eigenvalues.",
       "        This is the order of the related secular equation."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "        The dimension of the symmetric tridiagonal matrix.  N >= 0."],
     "QSIZ"=>
      ["[in]",
       "         QSIZ is INTEGER",
       "        The dimension of the unitary matrix used to reduce",
       "        the dense or band matrix to tridiagonal form.",
       "        QSIZ >= N if ICOMPQ = 1."],
     "Q"=>
      ["[in,out]",
       "         Q is COMPLEX*16 array, dimension (LDQ,N)",
       "        On entry, Q contains the eigenvectors of the partially solved",
       "        system which has been previously updated in matrix",
       "        multiplies with other partially solved eigensystems.",
       "        On exit, Q contains the trailing (N-K) updated eigenvectors",
       "        (those which were deflated) in its last N-K columns."],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "        The leading dimension of the array Q.  LDQ >= max( 1, N )."],
     "D"=>
      ["[in,out]",
       "         D is DOUBLE PRECISION array, dimension (N)",
       "        On entry, D contains the eigenvalues of the two submatrices to",
       "        be combined.  On exit, D contains the trailing (N-K) updated",
       "        eigenvalues (those which were deflated) sorted into increasing",
       "        order."],
     "RHO"=>
      ["[in,out]",
       "         RHO is DOUBLE PRECISION",
       "        Contains the off diagonal element associated with the rank-1",
       "        cut which originally split the two submatrices which are now",
       "        being recombined. RHO is modified during the computation to",
       "        the value required by DLAED3."],
     "CUTPNT"=>
      ["[in]",
       "         CUTPNT is INTEGER",
       "        Contains the location of the last eigenvalue in the leading",
       "        sub-matrix.  MIN(1,N) <= CUTPNT <= N."],
     "Z"=>
      ["[in]",
       "         Z is DOUBLE PRECISION array, dimension (N)",
       "        On input this vector contains the updating vector (the last",
       "        row of the first sub-eigenvector matrix and the first row of",
       "        the second sub-eigenvector matrix).  The contents of Z are",
       "        destroyed during the updating process."],
     "DLAMDA"=>
      ["[out]",
       "         DLAMDA is DOUBLE PRECISION array, dimension (N)",
       "        Contains a copy of the first K eigenvalues which will be used",
       "        by DLAED3 to form the secular equation."],
     "Q2"=>
      ["[out]",
       "         Q2 is COMPLEX*16 array, dimension (LDQ2,N)",
       "        If ICOMPQ = 0, Q2 is not referenced.  Otherwise,",
       "        Contains a copy of the first K eigenvectors which will be used",
       "        by DLAED7 in a matrix multiply (DGEMM) to update the new",
       "        eigenvectors."],
     "LDQ2"=>
      ["[in]",
       "         LDQ2 is INTEGER",
       "        The leading dimension of the array Q2.  LDQ2 >= max( 1, N )."],
     "W"=>
      ["[out]",
       "         W is DOUBLE PRECISION array, dimension (N)",
       "        This will hold the first k values of the final",
       "        deflation-altered z-vector and will be passed to DLAED3."],
     "INDXP"=>
      ["[out]",
       "         INDXP is INTEGER array, dimension (N)",
       "        This will contain the permutation used to place deflated",
       "        values of D at the end of the array. On output INDXP(1:K)",
       "        points to the nondeflated D-values and INDXP(K+1:N)",
       "        points to the deflated eigenvalues."],
     "INDX"=>
      ["[out]",
       "         INDX is INTEGER array, dimension (N)",
       "        This will contain the permutation used to sort the contents of",
       "        D into ascending order."],
     "INDXQ"=>
      ["[in]",
       "         INDXQ is INTEGER array, dimension (N)",
       "        This contains the permutation which separately sorts the two",
       "        sub-problems in D into ascending order.  Note that elements in",
       "        the second half of this permutation must first have CUTPNT",
       "        added to their values in order to be accurate."],
     "PERM"=>
      ["[out]",
       "         PERM is INTEGER array, dimension (N)",
       "        Contains the permutations (from deflation and sorting) to be",
       "        applied to each eigenblock."],
     "GIVPTR"=>
      ["[out]",
       "         GIVPTR is INTEGER",
       "        Contains the number of Givens rotations which took place in",
       "        this subproblem."],
     "GIVCOL"=>
      ["[out]",
       "         GIVCOL is INTEGER array, dimension (2, N)",
       "        Each pair of numbers indicates a pair of columns to take place",
       "        in a Givens rotation."],
     "GIVNUM"=>
      ["[out]",
       "         GIVNUM is DOUBLE PRECISION array, dimension (2, N)",
       "        Each number indicates the S value to be used in the",
       "        corresponding Givens rotation."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value."]}},
 "slaed9"=>
  {"summary"=>
    ["SLAED9 finds the roots of the secular equation, as defined by the",
     "values in D, Z, and RHO, between KSTART and KSTOP.  It makes the",
     "appropriate calls to SLAED4 and then stores the new matrix of",
     "eigenvectors for use in calculating the next level of Z vectors."],
   "param"=>
    {"K"=>
      ["[in]",
       "         K is INTEGER",
       "         The number of terms in the rational function to be solved by",
       "         SLAED4.  K >= 0."],
     "KSTART"=>["[in]", "         KSTART is INTEGER"],
     "KSTOP"=>
      ["[in]",
       "         KSTOP is INTEGER",
       "         The updated eigenvalues Lambda(I), KSTART <= I <= KSTOP",
       "         are to be computed.  1 <= KSTART <= KSTOP <= K."],
     "N"=>
      ["[in]",
       "         N is INTEGER",
       "         The number of rows and columns in the Q matrix.",
       "         N >= K (delation may result in N > K)."],
     "D"=>
      ["[out]",
       "         D is REAL array, dimension (N)",
       "         D(I) contains the updated eigenvalues",
       "         for KSTART <= I <= KSTOP."],
     "Q"=>["[out]", "         Q is REAL array, dimension (LDQ,N)"],
     "LDQ"=>
      ["[in]",
       "         LDQ is INTEGER",
       "         The leading dimension of the array Q.  LDQ >= max( 1, N )."],
     "RHO"=>
      ["[in]",
       "         RHO is REAL",
       "         The value of the parameter in the rank one update equation.",
       "         RHO >= 0 required."],
     "DLAMDA"=>
      ["[in]",
       "         DLAMDA is REAL array, dimension (K)",
       "         The first K elements of this array contain the old roots",
       "         of the deflated updating problem.  These are the poles",
       "         of the secular equation."],
     "W"=>
      ["[in]",
       "         W is REAL array, dimension (K)",
       "         The first K elements of this array contain the components",
       "         of the deflation-adjusted updating vector."],
     "S"=>
      ["[out]",
       "         S is REAL array, dimension (LDS, K)",
       "         Will contain the eigenvectors of the repaired matrix which",
       "         will be stored for subsequent Z vector calculation and",
       "         multiplied by the previously accumulated eigenvectors",
       "         to update the system."],
     "LDS"=>
      ["[in]",
       "         LDS is INTEGER",
       "         The leading dimension of S.  LDS >= max( 1, K )."],
     "INFO"=>
      ["[out]",
       "         INFO is INTEGER",
       "         = 0:  successful exit.",
       "         < 0:  if INFO = -i, the i-th argument had an illegal value.",
       "         > 0:  if INFO = 1, an eigenvalue did not converge"]}}}
