RubyGems - ruby-lapack - Versions diffs - 1.4.1a → 1.5 - Mend

ruby-lapack 1.4.1a → 1.5

Files changed (1638) hide show

data/doc/csp.html DELETED Viewed

@@ -1,905 +0,0 @@
-<HTML>
-  <HEAD>
-    <TITLE>COMPLEX routines for symmetric, packed storage matrix</TITLE>
-  </HEAD>
-  <BODY>
-    <A NAME="top"></A>
-    <H1>COMPLEX routines for symmetric, packed storage matrix</H1>
-    <UL>
-      <LI><A HREF="#cspcon">cspcon</A></LI>
-      <LI><A HREF="#cspmv">cspmv</A></LI>
-      <LI><A HREF="#cspr">cspr</A></LI>
-      <LI><A HREF="#csprfs">csprfs</A></LI>
-      <LI><A HREF="#cspsv">cspsv</A></LI>
-      <LI><A HREF="#cspsvx">cspsvx</A></LI>
-      <LI><A HREF="#csptrf">csptrf</A></LI>
-      <LI><A HREF="#csptri">csptri</A></LI>
-      <LI><A HREF="#csptrs">csptrs</A></LI>
-    </UL>
-    <A NAME="cspcon"></A>
-    <H2>cspcon</H2>
-    <PRE>
-USAGE:
-  rcond, info = NumRu::Lapack.cspcon( uplo, ap, ipiv, anorm, [:usage => usage, :help => help])
-FORTRAN MANUAL
-      SUBROUTINE CSPCON( UPLO, N, AP, IPIV, ANORM, RCOND, WORK, INFO )
-*  Purpose
-*  =======
-*
-*  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))).
-*
-*  Arguments
-*  =========
-*
-*  UPLO    (input) 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       (input) INTEGER
-*          The order of the matrix A.  N >= 0.
-*
-*  AP      (input) 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    (input) INTEGER array, dimension (N)
-*          Details of the interchanges and the block structure of D
-*          as determined by CSPTRF.
-*
-*  ANORM   (input) REAL
-*          The 1-norm of the original matrix A.
-*
-*  RCOND   (output) 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    (workspace) COMPLEX array, dimension (2*N)
-*
-*  INFO    (output) INTEGER
-*          = 0:  successful exit
-*          < 0:  if INFO = -i, the i-th argument had an illegal value
-*
-*  =====================================================================
-*
-    </PRE>
-    <A HREF="#top">go to the page top</A>
-    <A NAME="cspmv"></A>
-    <H2>cspmv</H2>
-    <PRE>
-USAGE:
-  y = NumRu::Lapack.cspmv( uplo, alpha, ap, x, incx, beta, y, incy, [:usage => usage, :help => help])
-FORTRAN MANUAL
-      SUBROUTINE CSPMV( UPLO, N, ALPHA, AP, X, INCX, BETA, Y, INCY )
-*  Purpose
-*  =======
-*
-*  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.
-*
-*  Arguments
-*  ==========
-*
-*  UPLO     (input) 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        (input) INTEGER
-*           On entry, N specifies the order of the matrix A.
-*           N must be at least zero.
-*           Unchanged on exit.
-*
-*  ALPHA    (input) COMPLEX
-*           On entry, ALPHA specifies the scalar alpha.
-*           Unchanged on exit.
-*
-*  AP       (input) 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        (input) 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     (input) INTEGER
-*           On entry, INCX specifies the increment for the elements of
-*           X. INCX must not be zero.
-*           Unchanged on exit.
-*
-*  BETA     (input) 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        (input/output) 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     (input) INTEGER
-*           On entry, INCY specifies the increment for the elements of
-*           Y. INCY must not be zero.
-*           Unchanged on exit.
-*
-* =====================================================================
-*
-    </PRE>
-    <A HREF="#top">go to the page top</A>
-    <A NAME="cspr"></A>
-    <H2>cspr</H2>
-    <PRE>
-USAGE:
-  ap = NumRu::Lapack.cspr( uplo, n, alpha, x, incx, ap, [:usage => usage, :help => help])
-FORTRAN MANUAL
-      SUBROUTINE CSPR( UPLO, N, ALPHA, X, INCX, AP )
-*  Purpose
-*  =======
-*
-*  CSPR    performs the symmetric rank 1 operation
-*
-*     A := alpha*x*conjg( x' ) + 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.
-*
-*  Arguments
-*  ==========
-*
-*  UPLO     (input) 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        (input) INTEGER
-*           On entry, N specifies the order of the matrix A.
-*           N must be at least zero.
-*           Unchanged on exit.
-*
-*  ALPHA    (input) COMPLEX
-*           On entry, ALPHA specifies the scalar alpha.
-*           Unchanged on exit.
-*
-*  X        (input) 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     (input) INTEGER
-*           On entry, INCX specifies the increment for the elements of
-*           X. INCX must not be zero.
-*           Unchanged on exit.
-*
-*  AP       (input/output) 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.
-*
-* =====================================================================
-*
-    </PRE>
-    <A HREF="#top">go to the page top</A>
-    <A NAME="csprfs"></A>
-    <H2>csprfs</H2>
-    <PRE>
-USAGE:
-  ferr, berr, info, x = NumRu::Lapack.csprfs( uplo, ap, afp, ipiv, b, x, [:usage => usage, :help => help])
-FORTRAN MANUAL
-      SUBROUTINE CSPRFS( UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX, FERR, BERR, WORK, RWORK, INFO )
-*  Purpose
-*  =======
-*
-*  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.
-*
-*  Arguments
-*  =========
-*
-*  UPLO    (input) CHARACTER*1
-*          = 'U':  Upper triangle of A is stored;
-*          = 'L':  Lower triangle of A is stored.
-*
-*  N       (input) INTEGER
-*          The order of the matrix A.  N >= 0.
-*
-*  NRHS    (input) INTEGER
-*          The number of right hand sides, i.e., the number of columns
-*          of the matrices B and X.  NRHS >= 0.
-*
-*  AP      (input) 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     (input) 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    (input) INTEGER array, dimension (N)
-*          Details of the interchanges and the block structure of D
-*          as determined by CSPTRF.
-*
-*  B       (input) COMPLEX array, dimension (LDB,NRHS)
-*          The right hand side matrix B.
-*
-*  LDB     (input) INTEGER
-*          The leading dimension of the array B.  LDB >= max(1,N).
-*
-*  X       (input/output) COMPLEX array, dimension (LDX,NRHS)
-*          On entry, the solution matrix X, as computed by CSPTRS.
-*          On exit, the improved solution matrix X.
-*
-*  LDX     (input) INTEGER
-*          The leading dimension of the array X.  LDX >= max(1,N).
-*
-*  FERR    (output) 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    (output) 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    (workspace) COMPLEX array, dimension (2*N)
-*
-*  RWORK   (workspace) REAL array, dimension (N)
-*
-*  INFO    (output) INTEGER
-*          = 0:  successful exit
-*          < 0:  if INFO = -i, the i-th argument had an illegal value
-*
-*  Internal Parameters
-*  ===================
-*
-*  ITMAX is the maximum number of steps of iterative refinement.
-*
-*  =====================================================================
-*
-    </PRE>
-    <A HREF="#top">go to the page top</A>
-    <A NAME="cspsv"></A>
-    <H2>cspsv</H2>
-    <PRE>
-USAGE:
-  ipiv, info, ap, b = NumRu::Lapack.cspsv( uplo, ap, b, [:usage => usage, :help => help])
-FORTRAN MANUAL
-      SUBROUTINE CSPSV( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO )
-*  Purpose
-*  =======
-*
-*  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.
-*
-*  Arguments
-*  =========
-*
-*  UPLO    (input) CHARACTER*1
-*          = 'U':  Upper triangle of A is stored;
-*          = 'L':  Lower triangle of A is stored.
-*
-*  N       (input) INTEGER
-*          The number of linear equations, i.e., the order of the
-*          matrix A.  N >= 0.
-*
-*  NRHS    (input) INTEGER
-*          The number of right hand sides, i.e., the number of columns
-*          of the matrix B.  NRHS >= 0.
-*
-*  AP      (input/output) 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    (output) 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       (input/output) 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     (input) INTEGER
-*          The leading dimension of the array B.  LDB >= max(1,N).
-*
-*  INFO    (output) 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.
-*
-*  Further Details
-*  ===============
-*
-*  The packed storage scheme is illustrated by the following example
-*  when N = 4, UPLO = 'U':
-*
-*  Two-dimensional storage of the symmetric matrix A:
-*
-*     a11 a12 a13 a14
-*         a22 a23 a24
-*             a33 a34     (aij = aji)
-*                 a44
-*
-*  Packed storage of the upper triangle of A:
-*
-*  AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ]
-*
-*  =====================================================================
-*
-*     .. External Functions ..
-      LOGICAL            LSAME
-      EXTERNAL           LSAME
-*     ..
-*     .. External Subroutines ..
-      EXTERNAL           CSPTRF, CSPTRS, XERBLA
-*     ..
-*     .. Intrinsic Functions ..
-      INTRINSIC          MAX
-*     ..
-    </PRE>
-    <A HREF="#top">go to the page top</A>
-    <A NAME="cspsvx"></A>
-    <H2>cspsvx</H2>
-    <PRE>
-USAGE:
-  x, rcond, ferr, berr, info, afp, ipiv = NumRu::Lapack.cspsvx( fact, uplo, ap, afp, ipiv, b, [:usage => usage, :help => help])
-FORTRAN MANUAL
-      SUBROUTINE CSPSVX( FACT, UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX, RCOND, FERR, BERR, WORK, RWORK, INFO )
-*  Purpose
-*  =======
-*
-*  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.
-*
-*  Description
-*  ===========
-*
-*  The following steps are performed:
-*
-*  1. If FACT = 'N', 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.
-*
-*  2. If some D(i,i)=0, so that D is exactly singular, then the routine
-*     returns with INFO = i. Otherwise, the factored form of A is used
-*     to estimate the condition number of the matrix A.  If the
-*     reciprocal of the condition number is less than machine precision,
-*     INFO = N+1 is returned as a warning, but the routine still goes on
-*     to solve for X and compute error bounds as described below.
-*
-*  3. The system of equations is solved for X using the factored form
-*     of A.
-*
-*  4. Iterative refinement is applied to improve the computed solution
-*     matrix and calculate error bounds and backward error estimates
-*     for it.
-*
-*  Arguments
-*  =========
-*
-*  FACT    (input) CHARACTER*1
-*          Specifies whether or not the factored form of A has been
-*          supplied on entry.
-*          = 'F':  On entry, AFP and IPIV contain the factored form
-*                  of A.  AP, AFP and IPIV will not be modified.
-*          = 'N':  The matrix A will be copied to AFP and factored.
-*
-*  UPLO    (input) CHARACTER*1
-*          = 'U':  Upper triangle of A is stored;
-*          = 'L':  Lower triangle of A is stored.
-*
-*  N       (input) INTEGER
-*          The number of linear equations, i.e., the order of the
-*          matrix A.  N >= 0.
-*
-*  NRHS    (input) INTEGER
-*          The number of right hand sides, i.e., the number of columns
-*          of the matrices B and X.  NRHS >= 0.
-*
-*  AP      (input) 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.
-*          See below for further details.
-*
-*  AFP     (input or output) COMPLEX array, dimension (N*(N+1)/2)
-*          If FACT = 'F', then AFP is an input argument and on entry
-*          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 in the same storage format as A.
-*
-*          If FACT = 'N', then AFP is an output argument and on exit
-*          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 in the same storage format as A.
-*
-*  IPIV    (input or output) INTEGER array, dimension (N)
-*          If FACT = 'F', then IPIV is an input argument and on entry
-*          contains 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.
-*
-*          If FACT = 'N', then IPIV is an output argument and on exit
-*          contains details of the interchanges and the block structure
-*          of D, as determined by CSPTRF.
-*
-*  B       (input) COMPLEX array, dimension (LDB,NRHS)
-*          The N-by-NRHS right hand side matrix B.
-*
-*  LDB     (input) INTEGER
-*          The leading dimension of the array B.  LDB >= max(1,N).
-*
-*  X       (output) COMPLEX array, dimension (LDX,NRHS)
-*          If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X.
-*
-*  LDX     (input) INTEGER
-*          The leading dimension of the array X.  LDX >= max(1,N).
-*
-*  RCOND   (output) REAL
-*          The estimate of the reciprocal condition number of the matrix
-*          A.  If RCOND is less than the machine precision (in
-*          particular, if RCOND = 0), the matrix is singular to working
-*          precision.  This condition is indicated by a return code of
-*          INFO > 0.
-*
-*  FERR    (output) 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    (output) 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    (workspace) COMPLEX array, dimension (2*N)
-*
-*  RWORK   (workspace) REAL array, dimension (N)
-*
-*  INFO    (output) INTEGER
-*          = 0: successful exit
-*          < 0: if INFO = -i, the i-th argument had an illegal value
-*          > 0:  if INFO = i, and i is
-*                <= N:  D(i,i) is exactly zero.  The factorization
-*                       has been completed but the factor D is exactly
-*                       singular, so the solution and error bounds could
-*                       not be computed. RCOND = 0 is returned.
-*                = N+1: D is nonsingular, but RCOND is less than machine
-*                       precision, meaning that the matrix is singular
-*                       to working precision.  Nevertheless, the
-*                       solution and error bounds are computed because
-*                       there are a number of situations where the
-*                       computed solution can be more accurate than the
-*                       value of RCOND would suggest.
-*
-*  Further Details
-*  ===============
-*
-*  The packed storage scheme is illustrated by the following example
-*  when N = 4, UPLO = 'U':
-*
-*  Two-dimensional storage of the symmetric matrix A:
-*
-*     a11 a12 a13 a14
-*         a22 a23 a24
-*             a33 a34     (aij = aji)
-*                 a44
-*
-*  Packed storage of the upper triangle of A:
-*
-*  AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ]
-*
-*  =====================================================================
-*
-    </PRE>
-    <A HREF="#top">go to the page top</A>
-    <A NAME="csptrf"></A>
-    <H2>csptrf</H2>
-    <PRE>
-USAGE:
-  ipiv, info, ap = NumRu::Lapack.csptrf( uplo, ap, [:usage => usage, :help => help])
-FORTRAN MANUAL
-      SUBROUTINE CSPTRF( UPLO, N, AP, IPIV, INFO )
-*  Purpose
-*  =======
-*
-*  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.
-*
-*  Arguments
-*  =========
-*
-*  UPLO    (input) CHARACTER*1
-*          = 'U':  Upper triangle of A is stored;
-*          = 'L':  Lower triangle of A is stored.
-*
-*  N       (input) INTEGER
-*          The order of the matrix A.  N >= 0.
-*
-*  AP      (input/output) 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    (output) 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    (output) 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.
-*
-*  Further Details
-*  ===============
-*
-*  5-96 - Based on modifications by J. Lewis, Boeing Computer Services
-*         Company
-*
-*  If UPLO = 'U', then A = U*D*U', where
-*     U = P(n)*U(n)* ... *P(k)U(k)* ...,
-*  i.e., U is a product of terms P(k)*U(k), where k decreases from n to
-*  1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
-*  and 2-by-2 diagonal blocks D(k).  P(k) is a permutation matrix as
-*  defined by IPIV(k), and U(k) is a unit upper triangular matrix, such
-*  that if the diagonal block D(k) is of order s (s = 1 or 2), then
-*
-*             (   I    v    0   )   k-s
-*     U(k) =  (   0    I    0   )   s
-*             (   0    0    I   )   n-k
-*                k-s   s   n-k
-*
-*  If s = 1, D(k) overwrites A(k,k), and v overwrites A(1:k-1,k).
-*  If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
-*  and A(k,k), and v overwrites A(1:k-2,k-1:k).
-*
-*  If UPLO = 'L', then A = L*D*L', where
-*     L = P(1)*L(1)* ... *P(k)*L(k)* ...,
-*  i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
-*  n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
-*  and 2-by-2 diagonal blocks D(k).  P(k) is a permutation matrix as
-*  defined by IPIV(k), and L(k) is a unit lower triangular matrix, such
-*  that if the diagonal block D(k) is of order s (s = 1 or 2), then
-*
-*             (   I    0     0   )  k-1
-*     L(k) =  (   0    I     0   )  s
-*             (   0    v     I   )  n-k-s+1
-*                k-1   s  n-k-s+1
-*
-*  If s = 1, D(k) overwrites A(k,k), and v overwrites A(k+1:n,k).
-*  If s = 2, the lower triangle of D(k) overwrites A(k,k), A(k+1,k),
-*  and A(k+1,k+1), and v overwrites A(k+2:n,k:k+1).
-*
-*  =====================================================================
-*
-    </PRE>
-    <A HREF="#top">go to the page top</A>
-    <A NAME="csptri"></A>
-    <H2>csptri</H2>
-    <PRE>
-USAGE:
-  info, ap = NumRu::Lapack.csptri( uplo, ap, ipiv, [:usage => usage, :help => help])
-FORTRAN MANUAL
-      SUBROUTINE CSPTRI( UPLO, N, AP, IPIV, WORK, INFO )
-*  Purpose
-*  =======
-*
-*  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.
-*
-*  Arguments
-*  =========
-*
-*  UPLO    (input) 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       (input) INTEGER
-*          The order of the matrix A.  N >= 0.
-*
-*  AP      (input/output) 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    (input) INTEGER array, dimension (N)
-*          Details of the interchanges and the block structure of D
-*          as determined by CSPTRF.
-*
-*  WORK    (workspace) COMPLEX array, dimension (N)
-*
-*  INFO    (output) 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.
-*
-*  =====================================================================
-*
-    </PRE>
-    <A HREF="#top">go to the page top</A>
-    <A NAME="csptrs"></A>
-    <H2>csptrs</H2>
-    <PRE>
-USAGE:
-  info, b = NumRu::Lapack.csptrs( uplo, ap, ipiv, b, [:usage => usage, :help => help])
-FORTRAN MANUAL
-      SUBROUTINE CSPTRS( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO )
-*  Purpose
-*  =======
-*
-*  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.
-*
-*  Arguments
-*  =========
-*
-*  UPLO    (input) 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       (input) INTEGER
-*          The order of the matrix A.  N >= 0.
-*
-*  NRHS    (input) INTEGER
-*          The number of right hand sides, i.e., the number of columns
-*          of the matrix B.  NRHS >= 0.
-*
-*  AP      (input) 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    (input) INTEGER array, dimension (N)
-*          Details of the interchanges and the block structure of D
-*          as determined by CSPTRF.
-*
-*  B       (input/output) COMPLEX array, dimension (LDB,NRHS)
-*          On entry, the right hand side matrix B.
-*          On exit, the solution matrix X.
-*
-*  LDB     (input) INTEGER
-*          The leading dimension of the array B.  LDB >= max(1,N).
-*
-*  INFO    (output) INTEGER
-*          = 0:  successful exit
-*          < 0: if INFO = -i, the i-th argument had an illegal value
-*
-*  =====================================================================
-*
-    </PRE>
-    <A HREF="#top">go to the page top</A>
-    <HR />
-    <A HREF="c.html">back to matrix types</A><BR>
-    <A HREF="c.html">back to data types</A>
-  </BODY>
-</HTML>