Fix some typos in code and comments

SRC/zhetf2_rk.f

@@ -417,7 +417,7 @@ SUBROUTINE ZHETF2_RK( UPLO, N, A, LDA, E, IPIV, INFO )
 *
 *                 Case(2)
 *                 Equivalent to testing for
-*                 ABS( REAL( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
+*                 ABS( DBLE( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
 *                 (used to handle NaN and Inf)
 *
                   IF( .NOT.( ABS( DBLE( A( IMAX, IMAX ) ) )
@@ -770,7 +770,7 @@ SUBROUTINE ZHETF2_RK( UPLO, N, A, LDA, E, IPIV, INFO )
 *
 *                 Case(2)
 *                 Equivalent to testing for
-*                 ABS( REAL( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
+*                 ABS( DBLE( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
 *                 (used to handle NaN and Inf)
 *
                   IF( .NOT.( ABS( DBLE( A( IMAX, IMAX ) ) )

SRC/zhetf2_rook.f

@@ -357,7 +357,7 @@ SUBROUTINE ZHETF2_ROOK( UPLO, N, A, LDA, IPIV, INFO )
 *
 *                 Case(2)
 *                 Equivalent to testing for
-*                 ABS( REAL( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
+*                 ABS( DBLE( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
 *                 (used to handle NaN and Inf)
 *
                   IF( .NOT.( ABS( DBLE( A( IMAX, IMAX ) ) )
@@ -669,7 +669,7 @@ SUBROUTINE ZHETF2_ROOK( UPLO, N, A, LDA, IPIV, INFO )
 *
 *                 Case(2)
 *                 Equivalent to testing for
-*                 ABS( REAL( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
+*                 ABS( DBLE( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
 *                 (used to handle NaN and Inf)
 *
                   IF( .NOT.( ABS( DBLE( A( IMAX, IMAX ) ) )

SRC/zlahef_rk.f

@@ -460,7 +460,7 @@ SUBROUTINE ZLAHEF_RK( UPLO, N, NB, KB, A, LDA, E, IPIV, W, LDW,
 *
 *                 Case(2)
 *                 Equivalent to testing for
-*                 ABS( REAL( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
+*                 ABS( DBLE( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
 *                 (used to handle NaN and Inf)
 *
                   IF( .NOT.( ABS( DBLE( W( IMAX,KW-1 ) ) )
@@ -599,7 +599,7 @@ SUBROUTINE ZLAHEF_RK( UPLO, N, NB, KB, A, LDA, E, IPIV, W, LDW,
 *                 A(1:k-1,k) := U(1:k-1,k) = W(1:k-1,kw)/D(k,k)
 *
 *              (NOTE: No need to use for Hermitian matrix
-*              A( K, K ) = REAL( W( K, K) ) to separately copy diagonal
+*              A( K, K ) = DBLE( W( K, K) ) to separately copy diagonal
 *              element D(k,k) from W (potentially saves only one load))
                CALL ZCOPY( K, W( 1, KW ), 1, A( 1, K ), 1 )
                IF( K.GT.1 ) THEN
@@ -912,7 +912,7 @@ SUBROUTINE ZLAHEF_RK( UPLO, N, NB, KB, A, LDA, E, IPIV, W, LDW,
 *
 *                 Case(2)
 *                 Equivalent to testing for
-*                 ABS( REAL( W( IMAX,K+1 ) ) ).GE.ALPHA*ROWMAX
+*                 ABS( DBLE( W( IMAX,K+1 ) ) ).GE.ALPHA*ROWMAX
 *                 (used to handle NaN and Inf)
 *
                   IF( .NOT.( ABS( DBLE( W( IMAX,K+1 ) ) )
@@ -1042,7 +1042,7 @@ SUBROUTINE ZLAHEF_RK( UPLO, N, NB, KB, A, LDA, E, IPIV, W, LDW,
 *                 A(k+1:N,k) := L(k+1:N,k) = W(k+1:N,k)/D(k,k)
 *
 *              (NOTE: No need to use for Hermitian matrix
-*              A( K, K ) = REAL( W( K, K) ) to separately copy diagonal
+*              A( K, K ) = DBLE( W( K, K) ) to separately copy diagonal
 *              element D(k,k) from W (potentially saves only one load))
                CALL ZCOPY( N-K+1, W( K, K ), 1, A( K, K ), 1 )
                IF( K.LT.N ) THEN

SRC/zlahef_rook.f

@@ -370,7 +370,7 @@ SUBROUTINE ZLAHEF_ROOK( UPLO, N, NB, KB, A, LDA, IPIV, W, LDW,
 *
 *                 Case(2)
 *                 Equivalent to testing for
-*                 ABS( REAL( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
+*                 ABS( DBLE( W( IMAX,KW-1 ) ) ).GE.ALPHA*ROWMAX
 *                 (used to handle NaN and Inf)
 *
                   IF( .NOT.( ABS( DBLE( W( IMAX,KW-1 ) ) )
@@ -509,7 +509,7 @@ SUBROUTINE ZLAHEF_ROOK( UPLO, N, NB, KB, A, LDA, IPIV, W, LDW,
 *                 A(1:k-1,k) := U(1:k-1,k) = W(1:k-1,kw)/D(k,k)
 *
 *              (NOTE: No need to use for Hermitian matrix
-*              A( K, K ) = REAL( W( K, K) ) to separately copy diagonal
+*              A( K, K ) = DBLE( W( K, K) ) to separately copy diagonal
 *              element D(k,k) from W (potentially saves only one load))
                CALL ZCOPY( K, W( 1, KW ), 1, A( 1, K ), 1 )
                IF( K.GT.1 ) THEN
@@ -833,7 +833,7 @@ SUBROUTINE ZLAHEF_ROOK( UPLO, N, NB, KB, A, LDA, IPIV, W, LDW,
 *
 *                 Case(2)
 *                 Equivalent to testing for
-*                 ABS( REAL( W( IMAX,K+1 ) ) ).GE.ALPHA*ROWMAX
+*                 ABS( DBLE( W( IMAX,K+1 ) ) ).GE.ALPHA*ROWMAX
 *                 (used to handle NaN and Inf)
 *
                   IF( .NOT.( ABS( DBLE( W( IMAX,K+1 ) ) )
@@ -963,7 +963,7 @@ SUBROUTINE ZLAHEF_ROOK( UPLO, N, NB, KB, A, LDA, IPIV, W, LDW,
 *                 A(k+1:N,k) := L(k+1:N,k) = W(k+1:N,k)/D(k,k)
 *
 *              (NOTE: No need to use for Hermitian matrix
-*              A( K, K ) = REAL( W( K, K) ) to separately copy diagonal
+*              A( K, K ) = DBLE( W( K, K) ) to separately copy diagonal
 *              element D(k,k) from W (potentially saves only one load))
                CALL ZCOPY( N-K+1, W( K, K ), 1, A( K, K ), 1 )
                IF( K.LT.N ) THEN

SRC/ztrevc3.f

@@ -286,13 +286,13 @@ SUBROUTINE ZTREVC3( SIDE, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR,
      $                   ZGEMM, DLABAD, ZLASET, ZLACPY
 *     ..
 *     .. Intrinsic Functions ..
-      INTRINSIC          ABS, DBLE, DCMPLX, CONJG, AIMAG, MAX
+      INTRINSIC          ABS, DBLE, DCMPLX, CONJG, DIMAG, MAX
 *     ..
 *     .. Statement Functions ..
       DOUBLE PRECISION   CABS1
 *     ..
 *     .. Statement Function definitions ..
-      CABS1( CDUM ) = ABS( DBLE( CDUM ) ) + ABS( AIMAG( CDUM ) )
+      CABS1( CDUM ) = ABS( DBLE( CDUM ) ) + ABS( DIMAG( CDUM ) )
 *     ..
 *     .. Executable Statements ..
 *

TESTING/EIG/cbdt01.f

@@ -28,13 +28,13 @@
 *> \verbatim
 *>
 *> CBDT01 reconstructs a general matrix A from its bidiagonal form
-*>    A = Q * B * P'
-*> where Q (m by min(m,n)) and P' (min(m,n) by n) are unitary
+*>    A = Q * B * P**H
+*> where Q (m by min(m,n)) and P**H (min(m,n) by n) are unitary
 *> matrices and B is bidiagonal.
 *>
 *> The test ratio to test the reduction is
-*>    RESID = norm( A - Q * B * PT ) / ( n * norm(A) * EPS )
-*> where PT = P' and EPS is the machine precision.
+*>    RESID = norm(A - Q * B * P**H) / ( n * norm(A) * EPS )
+*> where EPS is the machine precision.
 *> \endverbatim
 *
 *  Arguments:
@@ -49,7 +49,7 @@
 *> \param[in] N
 *> \verbatim
 *>          N is INTEGER
-*>          The number of columns of the matrices A and P'.
+*>          The number of columns of the matrices A and P**H.
 *> \endverbatim
 *>
 *> \param[in] KD
@@ -78,7 +78,7 @@
 *> \verbatim
 *>          Q is COMPLEX array, dimension (LDQ,N)
 *>          The m by min(m,n) unitary matrix Q in the reduction
-*>          A = Q * B * P'.
+*>          A = Q * B * P**H.
 *> \endverbatim
 *>
 *> \param[in] LDQ
@@ -103,8 +103,8 @@
 *> \param[in] PT
 *> \verbatim
 *>          PT is COMPLEX array, dimension (LDPT,N)
-*>          The min(m,n) by n unitary matrix P' in the reduction
-*>          A = Q * B * P'.
+*>          The min(m,n) by n unitary matrix P**H in the reduction
+*>          A = Q * B * P**H.
 *> \endverbatim
 *>
 *> \param[in] LDPT
@@ -127,7 +127,8 @@
 *> \param[out] RESID
 *> \verbatim
 *>          RESID is REAL
-*>          The test ratio:  norm(A - Q * B * P') / ( n * norm(A) * EPS )
+*>          The test ratio:
+*>          norm(A - Q * B * P**H) / ( n * norm(A) * EPS )
 *> \endverbatim
 *
 *  Authors:
@@ -187,7 +188,7 @@ SUBROUTINE CBDT01( M, N, KD, A, LDA, Q, LDQ, D, E, PT, LDPT, WORK,
          RETURN
       END IF
 *
-*     Compute A - Q * B * P' one column at a time.
+*     Compute A - Q * B * P**H one column at a time.
 *
       RESID = ZERO
       IF( KD.NE.0 ) THEN
@@ -265,7 +266,7 @@ SUBROUTINE CBDT01( M, N, KD, A, LDA, Q, LDQ, D, E, PT, LDPT, WORK,
          END IF
       END IF
 *
-*     Compute norm(A - Q * B * P') / ( n * norm(A) * EPS )
+*     Compute norm(A - Q * B * P**H) / ( n * norm(A) * EPS )
 *
       ANORM = CLANGE( '1', M, N, A, LDA, RWORK )
       EPS = SLAMCH( 'Precision' )

TESTING/EIG/cbdt02.f

@@ -27,9 +27,10 @@
 *>
 *> \verbatim
 *>
-*> CBDT02 tests the change of basis C = U' * B by computing the residual
+*> CBDT02 tests the change of basis C = U**H * B by computing the
+*> residual
 *>
-*>    RESID = norm( B - U * C ) / ( max(m,n) * norm(B) * EPS ),
+*>    RESID = norm(B - U * C) / ( max(m,n) * norm(B) * EPS ),
 *>
 *> where B and C are M by N matrices, U is an M by M orthogonal matrix,
 *> and EPS is the machine precision.
@@ -66,7 +67,7 @@
 *> \param[in] C
 *> \verbatim
 *>          C is COMPLEX array, dimension (LDC,N)
-*>          The m by n matrix C, assumed to contain U' * B.
+*>          The m by n matrix C, assumed to contain U**H * B.
 *> \endverbatim
 *>
 *> \param[in] LDC
@@ -100,7 +101,7 @@
 *> \param[out] RESID
 *> \verbatim
 *>          RESID is REAL
-*>          RESID = norm( B - U * C ) / ( max(m,n) * norm(B) * EPS ),
+*>          RESID = norm(B - U * C) / ( max(m,n) * norm(B) * EPS ),
 *> \endverbatim
 *
 *  Authors:
@@ -161,7 +162,7 @@ SUBROUTINE CBDT02( M, N, B, LDB, C, LDC, U, LDU, WORK, RWORK,
       REALMN = REAL( MAX( M, N ) )
       EPS = SLAMCH( 'Precision' )
 *
-*     Compute norm( B - U * C )
+*     Compute norm(B - U * C)
 *
       DO 10 J = 1, N
          CALL CCOPY( M, B( 1, J ), 1, WORK, 1 )

TESTING/EIG/clarhs.f

@@ -29,9 +29,8 @@
 *>
 *> CLARHS chooses a set of NRHS random solution vectors and sets
 *> up the right hand sides for the linear system
-*>    op( A ) * X = B,
-*> where op( A ) may be A, A**T (transpose of A), or A**H (conjugate
-*> transpose of A).
+*>    op(A) * X = B,
+*> where op(A) = A, A**T or A**H, depending on TRANS.
 *> \endverbatim
 *
 *  Arguments:
@@ -85,9 +84,9 @@
 *>          TRANS is CHARACTER*1
 *>          Used only if A is nonsymmetric; specifies the operation
 *>          applied to the matrix A.
-*>          = 'N':  B := A    * X
-*>          = 'T':  B := A**T * X
-*>          = 'C':  B := A**H * X
+*>          = 'N':  B := A    * X  (No transpose)
+*>          = 'T':  B := A**T * X  (Transpose)
+*>          = 'C':  B := A**H * X  (Conjugate transpose)
 *> \endverbatim
 *>
 *> \param[in] M
@@ -313,7 +312,7 @@ SUBROUTINE CLARHS( PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS,
    10    CONTINUE
       END IF
 *
-*     Multiply X by op( A ) using an appropriate
+*     Multiply X by op(A) using an appropriate
 *     matrix multiply routine.
 *
       IF( LSAMEN( 2, C2, 'GE' ) .OR. LSAMEN( 2, C2, 'QR' ) .OR.

TESTING/EIG/dbdt01.f

@@ -27,13 +27,13 @@
 *> \verbatim
 *>
 *> DBDT01 reconstructs a general matrix A from its bidiagonal form
-*>    A = Q * B * P'
-*> where Q (m by min(m,n)) and P' (min(m,n) by n) are orthogonal
+*>    A = Q * B * P**T
+*> where Q (m by min(m,n)) and P**T (min(m,n) by n) are orthogonal
 *> matrices and B is bidiagonal.
 *>
 *> The test ratio to test the reduction is
-*>    RESID = norm( A - Q * B * PT ) / ( n * norm(A) * EPS )
-*> where PT = P' and EPS is the machine precision.
+*>    RESID = norm(A - Q * B * P**T) / ( n * norm(A) * EPS )
+*> where EPS is the machine precision.
 *> \endverbatim
 *
 *  Arguments:
@@ -48,7 +48,7 @@
 *> \param[in] N
 *> \verbatim
 *>          N is INTEGER
-*>          The number of columns of the matrices A and P'.
+*>          The number of columns of the matrices A and P**T.
 *> \endverbatim
 *>
 *> \param[in] KD
@@ -77,7 +77,7 @@
 *> \verbatim
 *>          Q is DOUBLE PRECISION array, dimension (LDQ,N)
 *>          The m by min(m,n) orthogonal matrix Q in the reduction
-*>          A = Q * B * P'.
+*>          A = Q * B * P**T.
 *> \endverbatim
 *>
 *> \param[in] LDQ
@@ -102,8 +102,8 @@
 *> \param[in] PT
 *> \verbatim
 *>          PT is DOUBLE PRECISION array, dimension (LDPT,N)
-*>          The min(m,n) by n orthogonal matrix P' in the reduction
-*>          A = Q * B * P'.
+*>          The min(m,n) by n orthogonal matrix P**T in the reduction
+*>          A = Q * B * P**T.
 *> \endverbatim
 *>
 *> \param[in] LDPT
@@ -121,7 +121,8 @@
 *> \param[out] RESID
 *> \verbatim
 *>          RESID is DOUBLE PRECISION
-*>          The test ratio:  norm(A - Q * B * P') / ( n * norm(A) * EPS )
+*>          The test ratio:
+*>          norm(A - Q * B * P**T) / ( n * norm(A) * EPS )
 *> \endverbatim
 *
 *  Authors:
@@ -180,7 +181,7 @@ SUBROUTINE DBDT01( M, N, KD, A, LDA, Q, LDQ, D, E, PT, LDPT, WORK,
          RETURN
       END IF
 *
-*     Compute A - Q * B * P' one column at a time.
+*     Compute A - Q * B * P**T one column at a time.
 *
       RESID = ZERO
       IF( KD.NE.0 ) THEN
@@ -258,7 +259,7 @@ SUBROUTINE DBDT01( M, N, KD, A, LDA, Q, LDQ, D, E, PT, LDPT, WORK,
          END IF
       END IF
 *
-*     Compute norm(A - Q * B * P') / ( n * norm(A) * EPS )
+*     Compute norm(A - Q * B * P**T) / ( n * norm(A) * EPS )
 *
       ANORM = DLANGE( '1', M, N, A, LDA, WORK )
       EPS = DLAMCH( 'Precision' )

TESTING/EIG/dbdt02.f

@@ -25,9 +25,10 @@
 *>
 *> \verbatim
 *>
-*> DBDT02 tests the change of basis C = U' * B by computing the residual
+*> DBDT02 tests the change of basis C = U**H * B by computing the
+*> residual
 *>
-*>    RESID = norm( B - U * C ) / ( max(m,n) * norm(B) * EPS ),
+*>    RESID = norm(B - U * C) / ( max(m,n) * norm(B) * EPS ),
 *>
 *> where B and C are M by N matrices, U is an M by M orthogonal matrix,
 *> and EPS is the machine precision.
@@ -64,7 +65,7 @@
 *> \param[in] C
 *> \verbatim
 *>          C is DOUBLE PRECISION array, dimension (LDC,N)
-*>          The m by n matrix C, assumed to contain U' * B.
+*>          The m by n matrix C, assumed to contain U**H * B.
 *> \endverbatim
 *>
 *> \param[in] LDC
@@ -93,7 +94,7 @@
 *> \param[out] RESID
 *> \verbatim
 *>          RESID is DOUBLE PRECISION
-*>          RESID = norm( B - U * C ) / ( max(m,n) * norm(B) * EPS ),
+*>          RESID = norm(B - U * C) / ( max(m,n) * norm(B) * EPS ),
 *> \endverbatim
 *
 *  Authors:
@@ -152,7 +153,7 @@ SUBROUTINE DBDT02( M, N, B, LDB, C, LDC, U, LDU, WORK, RESID )
       REALMN = DBLE( MAX( M, N ) )
       EPS = DLAMCH( 'Precision' )
 *
-*     Compute norm( B - U * C )
+*     Compute norm(B - U * C)
 *
       DO 10 J = 1, N
          CALL DCOPY( M, B( 1, J ), 1, WORK, 1 )