* =======
*
* CGEBD2 reduces a complex general m by n matrix A to upper or lower
-* real bidiagonal form B by a unitary transformation: Q' * A * P = B.
+* 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.
*
*
ELSE
*
-* Overdetermined system of equations A' * X = B
+* Overdetermined system of equations A**H * X = B
*
-* B(1:N,1:NRHS) := inv(R') * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := inv(R**H) * B(1:N,1:NRHS)
*
CALL CTRTRS( 'Upper', 'Conjugate transpose','Non-unit',
$ N, NRHS, A, LDA, B, LDB, INFO )
*
ELSE
*
-* overdetermined system min || A' * X - B ||
+* overdetermined system min || A**H * X - B ||
*
* B(1:N,1:NRHS) := Q * B(1:N,1:NRHS)
*
*
* workspace at least NRHS, optimally NRHS*NB
*
-* B(1:M,1:NRHS) := inv(L') * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := inv(L**H) * B(1:M,1:NRHS)
*
CALL CTRTRS( 'Lower', 'Conjugate transpose', 'Non-unit',
$ M, NRHS, A, LDA, B, LDB, INFO )
* A * P = Q * [ T11 0 ] * Z
* [ 0 0 ]
* The minimum-norm solution is then
-* X = P * Z' [ inv(T11)*Q1'*B ]
-* [ 0 ]
+* 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
* TOLA REAL
* TOLB REAL
* TOLA and TOLB are the thresholds to determine the effective
-* rank of (A',B')**H. Generally, they are set to
+* rank of (A**H,B**H)**H. 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
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**H).
*
CALL CHETRS( UPLO, N, 1, AF, LDAF, IPIV, WORK, N, INFO )
DO 110 I = 1, N
CALL CAXPY( N-I, ALPHA, A( I+1, I ), 1, TAU( I ), 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v**H
+* A := A - v * w**H - w * v**H
*
CALL CHER2( UPLO, N-I, -ONE, A( I+1, I ), 1, TAU( I ), 1,
$ A( I+1, I+1 ), LDA )
$ LDWORK )
*
* Update the unreduced submatrix A(1:i-1,1:i-1), using an
-* update of the form: A := A - V*W' - W*V**H
+* update of the form: A := A - V*W**H - W*V**H
*
CALL CHER2K( UPLO, 'No transpose', I-1, NB, -CONE,
$ A( 1, I ), LDA, WORK, LDWORK, ONE, A, LDA )
$ TAU( I ), WORK, LDWORK )
*
* Update the unreduced submatrix A(i+nb:n,i+nb:n), using
-* an update of the form: A := A - V*W' - W*V**H
+* an update of the form: A := A - V*W**H - W*V**H
*
CALL CHER2K( UPLO, 'No transpose', N-I-NB+1, NB, -CONE,
$ A( I+NB, I ), LDA, WORK( NB+1 ), LDWORK, ONE,
IF( UPPER ) THEN
*
-* invA = P * inv(U**H)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**H)*inv(D)*inv(U)*P**H.
*
CALL CTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* U11T*invD1*U11->U11
+* U11**H*invD1*U11->U11
*
CALL CTRMM('L','U','C','U',NNB, NNB,
$ CONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
END DO
END DO
*
-* U01'invD*U01->A(CUT+I,CUT+J)
+* U01**H*invD*U01->A(CUT+I,CUT+J)
*
CALL CGEMM('C','N',NNB,NNB,CUT,CONE,A(1,CUT+1),LDA,
$ WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* U11 = U11T*invD1*U11 + U01'invD*U01
+* U11 = U11**H*invD1*U11 + U01**H*invD*U01
*
DO I=1,NNB
DO J=I,NNB
END DO
END DO
*
-* U01 = U00T*invD0*U01
+* U01 = U00**H*invD0*U01
*
CALL CTRMM('L',UPLO,'C','U',CUT, NNB,
$ CONE,A,LDA,WORK,N+NB+1)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**H)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**H: P * inv(U**H)*inv(D)*inv(U) *P**H
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U**H)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**H)*inv(D)*inv(U)*P**H.
*
CALL CTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* L11T*invD1*L11->L11
+* L11**H*invD1*L11->L11
*
CALL CTRMM('L',UPLO,'C','U',NNB, NNB,
$ CONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
*
IF ( (CUT+NNB) .LT. N ) THEN
*
-* L21T*invD2*L21->A(CUT+I,CUT+J)
+* L21**H*invD2*L21->A(CUT+I,CUT+J)
*
CALL CGEMM('C','N',NNB,NNB,N-NNB-CUT,CONE,A(CUT+NNB+1,CUT+1)
$ ,LDA,WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* L11 = L11T*invD1*L11 + U01'invD*U01
+* L11 = L11**H*invD1*L11 + U01**H*invD*U01
*
DO I=1,NNB
DO J=1,I
END DO
END DO
*
-* L01 = L22T*invD2*L21
+* L01 = L22**H*invD2*L21
*
CALL CTRMM('L',UPLO,'C','U', N-NNB-CUT, NNB,
$ CONE,A(CUT+NNB+1,CUT+NNB+1),LDA,WORK,N+NB+1)
END DO
ELSE
*
-* L11 = L11T*invD1*L11
+* L11 = L11**H*invD1*L11
*
DO I=1,NNB
DO J=1,I
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**H)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**H: P * inv(U**H)*inv(D)*inv(U) *P**H
*
I=N
DO WHILE ( I .GE. 1 )
*
* CHFRK performs one of the Hermitian rank--k operations
*
-* C := alpha*A*conjg( A' ) + beta*C,
+* C := alpha*A*A**H + beta*C,
*
* or
*
-* C := alpha*conjg( A' )*A + beta*C,
+* 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
* On entry, TRANS specifies the operation to be performed as
* follows:
*
-* TRANS = 'N' or 'n' C := alpha*A*conjg( A' ) + beta*C.
+* TRANS = 'N' or 'n' C := alpha*A*A**H + beta*C.
*
-* TRANS = 'C' or 'c' C := alpha*conjg( A' )*A + beta*C.
+* TRANS = 'C' or 'c' C := alpha*A**H*A + beta*C.
*
* Unchanged on exit.
*
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**H).
*
CALL CHPTRS( UPLO, N, 1, AFP, IPIV, WORK, N, INFO )
DO 110 I = 1, N
CALL CAXPY( N-I, ALPHA, AP( II+1 ), 1, TAU( I ), 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v**H
+* A := A - v * w**H - w * v**H
*
CALL CHPR2( UPLO, N-I, -ONE, AP( II+1 ), 1, TAU( I ), 1,
$ AP( I1I1 ) )
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**H).
*
IF ( CAPPLY ) THEN
DO I = 1, N
END DO
ELSE
*
-* Multiply by inv(X').
+* Multiply by inv(X**H).
*
DO I = 1, N
WORK( I ) = WORK( I ) / X( I )
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**H).
*
IF ( CAPPLY ) THEN
DO I = 1, N
END DO
ELSE
*
-* Multiply by inv(X').
+* Multiply by inv(X**H).
*
DO I = 1, N
WORK( I ) = WORK( I ) / X( I )
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**H).
*
IF ( CAPPLY ) THEN
DO I = 1, N
END DO
ELSE
*
-* Multiply by inv(X').
+* Multiply by inv(X**H).
*
DO I = 1, N
WORK( I ) = WORK( I ) / X( I )
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**H).
*
IF ( CAPPLY ) THEN
DO I = 1, N
END DO
ELSE
*
-* Multiply by inv(X').
+* Multiply by inv(X**H).
*
DO I = 1, N
WORK( I ) = WORK( I ) / X( I )
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**T).
*
IF ( CAPPLY ) THEN
DO I = 1, N
END DO
ELSE
*
-* Multiply by inv(X').
+* Multiply by inv(X**T).
*
DO I = 1, N
WORK( I ) = WORK( I ) / X( I )
* X (input/output) COMPLEX array, dimension (N)
* On an intermediate return, X should be overwritten by
* A * X, if KASE=1,
-* A' * X, if KASE=2,
-* where A' is the conjugate transpose of A, and CLACN2 must be
+* 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 (input/output) REAL
* KASE (input/output) 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' * X.
+* whether X should be overwritten by A * X or A**H * X.
* On the final return from CLACN2, KASE will again be 0.
*
* ISAVE (input/output) INTEGER array, dimension (3)
* X (input/output) COMPLEX array, dimension (N)
* On an intermediate return, X should be overwritten by
* A * X, if KASE=1,
-* A' * X, if KASE=2,
-* where A' is the conjugate transpose of A, and CLACON must be
+* 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 (input/output) REAL
* KASE (input/output) 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' * X.
+* whether X should be overwritten by A * X or A**H * X.
* On the final return from CLACON, KASE will again be 0.
*
* Further Details
*
* Choose CS1 = 1 and SN1 to satisfy the first equation, then
* scale the components of this eigenvector so that the matrix
-* of eigenvectors X satisfies X * X' = I . (No scaling is
+* of eigenvectors X satisfies X * X**T = I . (No scaling is
* done if the norm of the eigenvalue matrix is less than THRESH.)
*
SN1 = ( RT1-A ) / B
$ A( K+I-1, 1 ), LDA, ONE, A( K+1, I ), 1 )
CALL CLACGV( I-1, A( K+I-1, 1 ), LDA )
*
-* Apply I - V * T' * V**H to this column (call it b) from the
+* Apply I - V * T**H * V**H to this column (call it b) from the
* left, using the last column of T as workspace
*
* Let V = ( V1 ) and b = ( b1 ) (first I-1 rows)
*
* where V1 is unit lower triangular
*
-* w := V1' * b1
+* w := V1**H * b1
*
CALL CCOPY( I-1, A( K+1, I ), 1, T( 1, NB ), 1 )
CALL CTRMV( 'Lower', 'Conjugate transpose', 'UNIT',
* [ s*x ]
* xhat = [ c ]
* is an approximate singular vector of
-* [ L 0 ]
-* Lhat = [ w' gamma ]
+* [ 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]' and sestpr**2 is an eigenpair of the system
+* Note that [s c]**H and sestpr**2 is an eigenpair of the system
*
* diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ]
* [ conjg(gamma) ]
* POLES, GIVNUM, and Z.
*
* VT (input) REAL array, dimension ( LDU, SMLSIZ+1 ).
-* On entry, VT' contains the right singular vector matrices of
+* On entry, VT**H contains the right singular vector matrices of
* all subproblems at the bottom level.
*
* K (input) INTEGER array, dimension ( N ).
*
* Since B is complex, the following call to SGEMM is performed
* in two steps (real and imaginary parts). That is for V * B
-* (in the real version of the code V' is stored in WORK).
+* (in the real version of the code V**H is stored in WORK).
*
* CALL SGEMM( 'T', 'N', N, NRHS, N, ONE, WORK, N, B, LDB, ZERO,
* $ WORK( NWORK ), N )
ELSE
* A is xpose & A is k by n
IF( ILU.EQ.0 ) THEN
-* A' is upper
+* A**H is upper
DO J = 1, K - 2
CALL CLASSQ( J, A( 0+( K+J )*LDA ), 1, SCALE, S )
* U at A(0,k)
L = L + LDA + 1
END DO
ELSE
-* A' is lower
+* A**H is lower
DO J = 1, K - 1
CALL CLASSQ( J, A( 0+J*LDA ), 1, SCALE, S )
* U at A(0,0)
ELSE
* A is xpose
IF( ILU.EQ.0 ) THEN
-* A' is upper
+* A**H is upper
DO J = 1, K - 1
CALL CLASSQ( J, A( 0+( K+1+J )*LDA ), 1, SCALE, S )
* U at A(0,k+1)
END IF
END IF
ELSE
-* A' is lower
+* A**H is lower
DO J = 1, K - 1
CALL CLASSQ( J, A( 0+( J+1 )*LDA ), 1, SCALE, S )
* U at A(0,1)
CALL CLACPY( 'ALL', KNZ, JLEN, H( INCOL+1+J2, JCOL ),
$ LDH, WH( KZS+1, 1 ), LDWH )
*
-* ==== Multiply by U21' ====
+* ==== Multiply by U21**H ====
*
CALL CLASET( 'ALL', KZS, JLEN, ZERO, ZERO, WH, LDWH )
CALL CTRMM( 'L', 'U', 'C', 'N', KNZ, JLEN, ONE,
$ U( J2+1, 1+KZS ), LDU, WH( KZS+1, 1 ),
$ LDWH )
*
-* ==== Multiply top of H by U11' ====
+* ==== Multiply top of H by U11**H ====
*
CALL CGEMM( 'C', 'N', I2, JLEN, J2, ONE, U, LDU,
$ H( INCOL+1, JCOL ), LDH, ONE, WH, LDWH )
CALL CLACPY( 'ALL', J2, JLEN, H( INCOL+1, JCOL ), LDH,
$ WH( I2+1, 1 ), LDWH )
*
-* ==== Multiply by U21' ====
+* ==== Multiply by U21**H ====
*
CALL CTRMM( 'L', 'L', 'C', 'N', J2, JLEN, ONE,
$ U( 1, I2+1 ), LDU, WH( I2+1, 1 ), LDWH )
*
* W := C**H * V = (C1**H * V1 + C2**H * V2) (stored in WORK)
*
-* W := C1'
+* W := C1**H
*
DO 10 J = 1, K
CALL CCOPY( LASTC, C( J, 1 ), LDC, WORK( 1, J ), 1 )
* 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 = 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' * T * V
+* H = I - V**H * T * V
*
* Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
*
END IF
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form A * P'
+* Form A * P**T
*
IF( LSAME( PIVOT, 'V' ) ) THEN
IF( LSAME( DIRECT, 'F' ) ) THEN
* 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' denotes the transpose of A, x and b
+* 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
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**H).
*
CALL CPBTRS( UPLO, N, KD, 1, AFB, LDAFB, WORK, N, INFO )
DO 110 I = 1, N
*
* on entry: on exit:
*
-* * * a13 a24 a35 a46 a57 * * s13 s24 s53' s64' s75'
-* * a12 a23 a34 a45 a56 a67 * s12 s23 s34 s54' s65' s76'
-* a11 a22 a33 a44 a55 a66 a77 s11 s22 s33 s44 s55 s66 s77
+* * * a13 a24 a35 a46 a57 * * s13 s24 s53**H s64**H s75**H
+* * a12 a23 a34 a45 a56 a67 * s12 s23 s34 s54**H s65**H s76**H
+* a11 a22 a33 a44 a55 a66 a77 s11 s22 s33 s44 s55 s66 s77
*
* If UPLO = 'L', the array AB holds:
*
* on entry: on exit:
*
-* a11 a22 a33 a44 a55 a66 a77 s11 s22 s33 s44 s55 s66 s77
-* a21 a32 a43 a54 a65 a76 * s12' s23' s34' s54 s65 s76 *
-* a31 a42 a53 a64 a64 * * s13' s24' s53 s64 s75 * *
+* a11 a22 a33 a44 a55 a66 a77 s11 s22 s33 s44 s55 s66 s77
+* a21 a32 a43 a54 a65 a76 * s12**H s23**H s34**H s54 s65 s76 *
+* a31 a42 a53 a64 a64 * * s13**H s24**H s53 s64 s75 * *
*
-* Array elements marked * are not used by the routine; s12' denotes
+* Array elements marked * are not used by the routine; s12**H denotes
* conjg(s12); the diagonal elements of S are real.
*
* =====================================================================
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**H).
*
CALL CPOTRS( UPLO, N, 1, AF, LDAF, WORK, N, INFO )
DO 110 I = 1, N
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**H).
*
CALL CPPTRS( UPLO, N, 1, AFP, WORK, N, INFO )
DO 110 I = 1, N
* A = U**H * U , if UPLO = 'U', or
* A = L * L**H, if UPLO = 'L',
* where U is an upper triangular matrix, L is a lower triangular
-* matrix, and ' indicates conjugate transpose.
+* matrix, and **H indicates conjugate transpose.
*
* 3. If the leading i-by-i principal minor is not positive definite,
* then the routine returns with INFO = i. Otherwise, the factored
* pivoting of a complex Hermitian positive semidefinite matrix A.
*
* The factorization has the form
-* P' * A * P = U' * U , if UPLO = 'U',
-* P' * A * P = L * L', if UPLO = 'L',
+* 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.
*
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization P' * A * P = U' * U
+* Compute the Cholesky factorization P**T * A * P = U**H * U
*
DO 150 J = 1, N
*
*
ELSE
*
-* Compute the Cholesky factorization P' * A * P = L * L'
+* Compute the Cholesky factorization P**T * A * P = L * L**H
*
DO 180 J = 1, N
*
* pivoting of a complex Hermitian positive semidefinite matrix A.
*
* The factorization has the form
-* P' * A * P = U' * U , if UPLO = 'U',
-* P' * A * P = L * L', if UPLO = 'L',
+* 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.
*
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization P' * A * P = U' * U
+* Compute the Cholesky factorization P**T * A * P = U**H * U
*
DO 160 K = 1, N, NB
*
*
ELSE
*
-* Compute the Cholesky factorization P' * A * P = L * L'
+* Compute the Cholesky factorization P**T * A * P = L * L**H
*
DO 210 K = 1, N, NB
*
* m(i,j) = abs(A(i,j)), i = j,
* m(i,j) = -abs(A(i,j)), i .ne. j,
*
-* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**H.
+* and e = [ 1, 1, ..., 1 ]**T. Note M(A) = M(L)*D*M(L)**H.
*
* Solve M(L) * x = e.
*
* m(i,j) = abs(A(i,j)), i = j,
* m(i,j) = -abs(A(i,j)), i .ne. j,
*
-* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**H.
+* and e = [ 1, 1, ..., 1 ]**T. Note M(A) = M(L)*D*M(L)**H.
*
* Solve M(L) * x = e.
*
*
* CSPR performs the symmetric rank 1 operation
*
-* A := alpha*x*conjg( x' ) + A,
+* 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.
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL CSPTRS( UPLO, N, 1, AFP, IPIV, WORK, N, INFO )
DO 110 I = 1, N
*
* CSYR performs the symmetric rank 1 operation
*
-* A := alpha*x*( x' ) + A,
+* 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.
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL CSYTRS( UPLO, N, 1, AF, LDAF, IPIV, WORK, N, INFO )
DO 110 I = 1, N
IF( UPPER ) THEN
*
-* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P**T.
*
CALL CTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* U11T*invD1*U11->U11
+* U11**T*invD1*U11->U11
*
CALL CTRMM('L','U','T','U',NNB, NNB,
$ ONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
END DO
END DO
*
-* U01'invD*U01->A(CUT+I,CUT+J)
+* U01**T*invD*U01->A(CUT+I,CUT+J)
*
CALL CGEMM('T','N',NNB,NNB,CUT,ONE,A(1,CUT+1),LDA,
$ WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* U11 = U11T*invD1*U11 + U01'invD*U01
+* U11 = U11**T*invD1*U11 + U01**T*invD*U01
*
DO I=1,NNB
DO J=I,NNB
END DO
END DO
*
-* U01 = U00T*invD0*U01
+* U01 = U00**T*invD0*U01
*
CALL CTRMM('L',UPLO,'T','U',CUT, NNB,
$ ONE,A,LDA,WORK,N+NB+1)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**T: P * inv(U**T)*inv(D)*inv(U) *P**T
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P**T.
*
CALL CTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* L11T*invD1*L11->L11
+* L11**T*invD1*L11->L11
*
CALL CTRMM('L',UPLO,'T','U',NNB, NNB,
$ ONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
*
IF ( (CUT+NNB) .LT. N ) THEN
*
-* L21T*invD2*L21->A(CUT+I,CUT+J)
+* L21**T*invD2*L21->A(CUT+I,CUT+J)
*
CALL CGEMM('T','N',NNB,NNB,N-NNB-CUT,ONE,A(CUT+NNB+1,CUT+1)
$ ,LDA,WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* L11 = L11T*invD1*L11 + U01'invD*U01
+* L11 = L11**T*invD1*L11 + U01**T*invD*U01
*
DO I=1,NNB
DO J=1,I
END DO
END DO
*
-* L01 = L22T*invD2*L21
+* L01 = L22**T*invD2*L21
*
CALL CTRMM('L',UPLO,'T','U', N-NNB-CUT, NNB,
$ ONE,A(CUT+NNB+1,CUT+NNB+1),LDA,WORK,N+NB+1)
END DO
ELSE
*
-* L11 = L11T*invD1*L11
+* L11 = L11**T*invD1*L11
*
DO I=1,NNB
DO J=1,I
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**T: P * inv(U**T)*inv(D)*inv(U) *P**T
*
I=N
DO WHILE ( I .GE. 1 )
RCOND = ZERO
SMLNUM = SLAMCH( 'Safe minimum' )*REAL( MAX( N, 1 ) )
*
-* Compute the 1-norm of the triangular matrix A or A'.
+* Compute the 1-norm of the triangular matrix A or A**H.
*
ANORM = CLANTB( NORM, UPLO, DIAG, N, KD, AB, LDAB, RWORK )
*
$ AB, LDAB, WORK, SCALE, RWORK, INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**H).
*
CALL CLATBS( UPLO, 'Conjugate transpose', DIAG, NORMIN,
$ N, KD, AB, LDAB, WORK, SCALE, RWORK, INFO )
* 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 ) = conjg( A' ).
+* op( A ) = A or op( A ) = A**H.
*
* A is in Rectangular Full Packed (RFP) Format.
*
*
* CTGEXC reorders the generalized Schur decomposition of a complex
* matrix pair (A,B), using an unitary equivalence transformation
-* (A, B) := Q * (A, B) * Z', so that the diagonal block of (A, B) with
+* (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
* where sigma-min(Zu) is the smallest singular value of the
* (2*n1*n2)-by-(2*n1*n2) matrix
*
-* Zu = [ kron(In2, A11) -kron(A22', In1) ]
-* [ kron(In2, B11) -kron(B22', In1) ].
+* Zu = [ kron(In2, A11) -kron(A22**H, In1) ]
+* [ kron(In2, B11) -kron(B22**H, In1) ].
*
-* Here, Inx is the identity matrix of size nx and A22' is the
-* transpose of A22. kron(X, Y) is the Kronecker product between
+* Here, Inx is the identity matrix of size nx and A22**H is the
+* conjuguate transpose of A22. kron(X, Y) is the Kronecker product between
* the matrices X and Y.
*
* When DIF(2) is small, small changes in (A, B) can cause large changes
* In matrix notation solving equation (1) corresponds to solve
* Zx = scale * b, where Z is defined as
*
-* Z = [ kron(In, A) -kron(B', Im) ] (2)
-* [ kron(In, D) -kron(E', Im) ],
+* 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' is the transpose of X.
+* 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'y = scale*b
+* 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' * R + D' * L = scale * C (3)
-* R * B' + L * E' = scale * -F
+* 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.
DO 80 I = 1, M
DO 70 J = N, 1, -1
*
-* Build 2 by 2 system Z'
+* Build 2 by 2 system Z**H
*
Z( 1, 1 ) = CONJG( A( I, I ) )
Z( 2, 1 ) = -CONJG( B( J, J ) )
RHS( 1 ) = C( I, J )
RHS( 2 ) = F( I, J )
*
-* Solve Z' * x = RHS
+* Solve Z**H * x = RHS
*
CALL CGETC2( LDZ, Z, LDZ, IPIV, JPIV, IERR )
IF( IERR.GT.0 )
* In matrix notation (1) is equivalent to solve Zx = scale*b, where Z
* is defined as
*
-* Z = [ kron(In, A) -kron(B', Im) ] (2)
-* [ kron(In, D) -kron(E', Im) ],
+* 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' is the conjugate
+* 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.
*
$ WORK, SCALE, RWORK, INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**H).
*
CALL CLATPS( UPLO, 'Conjugate transpose', DIAG, NORMIN,
$ N, AP, WORK, SCALE, RWORK, INFO )
$ LDA, WORK, SCALE, RWORK, INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**H).
*
CALL CLATRS( UPLO, 'Conjugate transpose', DIAG, NORMIN,
$ N, A, LDA, WORK, SCALE, RWORK, INFO )
* 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
+* 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
+* 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'.
+* case N even and TRANSR = 'N'.
*
* RFP A RFP A
*
* -- -- --
* 02 12 22 50 51 52
*
-* Now let TRANSR = `C'. RFP A in both UPLO cases is just the conjugate-
+* Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
* transpose of RFP A above. One therefore gets:
*
*
* 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
+* 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
+* 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'.
+* case N odd and TRANSR = 'N'.
*
* RFP A RFP A
*
* -- --
* 01 11 44 40 41 42
*
-* Now let TRANSR = `C'. RFP A in both UPLO cases is just the conjugate-
+* Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
* transpose of RFP A above. One therefore gets:
*
*
END IF
ELSE
*
-* Form P', determined by a call to CGEBRD to reduce a k-by-n
+* Form P**H, determined by a call to CGEBRD to reduce a k-by-n
* matrix
*
IF( K.LT.N ) THEN
* If k >= n, assume m = n
*
* Shift the vectors which define the elementary reflectors one
-* row downward, and set the first row and column of P' to
+* row downward, and set the first row and column of P**H to
* those of the unit matrix
*
A( 1, 1 ) = ONE
60 CONTINUE
IF( N.GT.1 ) THEN
*
-* Form P'(2:n,2:n)
+* Form P**H(2:n,2:n)
*
CALL CUNGLQ( N-1, N-1, N-1, A( 2, 2 ), LDA, TAU, WORK,
$ LWORK, IINFO )
*
* VT (output) DOUBLE PRECISION array, dimension (LDVT,N)
* If COMPQ = 'I', then:
-* On exit, if INFO = 0, VT' contains the right singular
+* 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.
*
* =======
*
* DGBTRS solves a system of linear equations
-* A * X = B or A' * X = B
+* A * X = B or A**T * X = B
* with a general band matrix A using the LU factorization computed
* by DGBTRF.
*
* TRANS (input) CHARACTER*1
* Specifies the form of the system of equations.
* = 'N': A * X = B (No transpose)
-* = 'T': A'* X = B (Transpose)
-* = 'C': A'* X = B (Conjugate transpose = Transpose)
+* = 'T': A**T* X = B (Transpose)
+* = 'C': A**T* X = B (Conjugate transpose = Transpose)
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
ELSE
*
-* Solve A'*X = B.
+* Solve A**T*X = B.
*
DO 30 I = 1, NRHS
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**T*X = B, overwriting B with X.
*
CALL DTBSV( 'Upper', 'Transpose', 'Non-unit', N, KL+KU, AB,
$ LDAB, B( 1, I ), 1 )
30 CONTINUE
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**T*X = B, overwriting B with X.
*
IF( LNOTI ) THEN
DO 40 J = N - 1, 1, -1
* =======
*
* DGEBD2 reduces a real general m by n matrix A to upper or lower
-* bidiagonal form B by an orthogonal transformation: Q' * A * P = B.
+* 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.
*
*
ELSE
*
-* Overdetermined system of equations A' * X = B
+* Overdetermined system of equations A**T * X = B
*
-* B(1:N,1:NRHS) := inv(R') * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := inv(R**T) * B(1:N,1:NRHS)
*
CALL DTRTRS( 'Upper', 'Transpose', 'Non-unit', N, NRHS,
$ A, LDA, B, LDB, INFO )
*
ELSE
*
-* overdetermined system min || A' * X - B ||
+* overdetermined system min || A**T * X - B ||
*
* B(1:N,1:NRHS) := Q * B(1:N,1:NRHS)
*
*
* workspace at least NRHS, optimally NRHS*NB
*
-* B(1:M,1:NRHS) := inv(L') * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := inv(L**T) * B(1:M,1:NRHS)
*
CALL DTRTRS( 'Lower', 'Transpose', 'Non-unit', M, NRHS,
$ A, LDA, B, LDB, INFO )
* L (output) INTEGER
* On exit, K and L specify the dimension of the subblocks
* described in the Purpose section.
-* K + L = effective numerical rank of (A',B')**T.
+* K + L = effective numerical rank of (A**T,B**T)**T.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the M-by-N matrix A.
* =======
*
* DGTTRS solves one of the systems of equations
-* A*X = B or A'*X = B,
+* A*X = B or A**T*X = B,
* with a tridiagonal matrix A using the LU factorization computed
* by DGTTRF.
*
* TRANS (input) CHARACTER*1
* Specifies the form of the system of equations.
* = 'N': A * X = B (No transpose)
-* = 'T': A'* X = B (Transpose)
-* = 'C': A'* X = B (Conjugate transpose = Transpose)
+* = 'T': A**T* X = B (Transpose)
+* = 'C': A**T* X = B (Conjugate transpose = Transpose)
*
* N (input) INTEGER
* The order of the matrix A.
* =======
*
* DGTTS2 solves one of the systems of equations
-* A*X = B or A'*X = B,
+* A*X = B or A**T*X = B,
* with a tridiagonal matrix A using the LU factorization computed
* by DGTTRF.
*
* ITRANS (input) INTEGER
* Specifies the form of the system of equations.
* = 0: A * X = B (No transpose)
-* = 1: A'* X = B (Transpose)
-* = 2: A'* X = B (Conjugate transpose = Transpose)
+* = 1: A**T* X = B (Transpose)
+* = 2: A**T* X = B (Conjugate transpose = Transpose)
*
* N (input) INTEGER
* The order of the matrix A.
END IF
ELSE
*
-* Solve A' * X = B.
+* Solve A**T * X = B.
*
IF( NRHS.LE.1 ) THEN
*
-* Solve U'*x = b.
+* Solve U**T*x = b.
*
J = 1
70 CONTINUE
$ B( I-2, J ) ) / D( I )
80 CONTINUE
*
-* Solve L'*x = b.
+* Solve L**T*x = b.
*
DO 90 I = N - 1, 1, -1
IP = IPIV( I )
ELSE
DO 120 J = 1, NRHS
*
-* Solve U'*x = b.
+* Solve U**T*x = b.
*
B( 1, J ) = B( 1, J ) / D( 1 )
IF( N.GT.1 )
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**T).
*
IF ( CMODE .EQ. 1 ) THEN
DO I = 1, N
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**T).
*
IF ( CMODE .EQ. 1 ) THEN
DO I = 1, N
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**T).
*
IF ( CMODE .EQ. 1 ) THEN
DO I = 1, N
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**T).
*
IF ( CMODE .EQ. 1 ) THEN
DO I = 1, N
* X (input/output) DOUBLE PRECISION array, dimension (N)
* On an intermediate return, X should be overwritten by
* A * X, if KASE=1,
-* A' * X, if KASE=2,
+* A**T * X, if KASE=2,
* and DLACN2 must be re-called with all the other parameters
* unchanged.
*
* KASE (input/output) 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' * X.
+* whether X should be overwritten by A * X or A**T * X.
* On the final return from DLACN2, KASE will again be 0.
*
* ISAVE (input/output) INTEGER array, dimension (3)
* X (input/output) DOUBLE PRECISION array, dimension (N)
* On an intermediate return, X should be overwritten by
* A * X, if KASE=1,
-* A' * X, if KASE=2,
+* A**T * X, if KASE=2,
* and DLACON must be re-called with all the other parameters
* unchanged.
*
* KASE (input/output) 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' * X.
+* whether X should be overwritten by A * X or A**T * X.
* On the final return from DLACON, KASE will again be 0.
*
* Further Details
* of a full symmetric matrix (which was reduced to tridiagonal form)
* are desired.
*
-* T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)
+* T = Q(in) ( D(in) + RHO * Z*Z**T ) Q**T(in) = Q(out) * D(out) * Q**T(out)
*
-* where Z = Q'u, u is a vector of length N with ones in the
+* 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
VCRIT = BIGNUM
*
* Solve U*(xr,xi) = scale*(vr,vi) for a right eigenvector,
-* or U'*(xr,xi) = scale*(vr,vi) for a left eigenvector,
+* or U**T*(xr,xi) = scale*(vr,vi) for a left eigenvector,
* overwriting (xr,xi) on (vr,vi).
*
DO 250 I = I1, I2, I3
* U = ( CSU SNU ), V = ( CSV SNV ), Q = ( CSQ SNQ )
* ( -SNU CSU ) ( -SNV CSV ) ( -SNQ CSQ )
*
-* Z' denotes the transpose of Z.
+* Z**T denotes the transpose of Z.
*
*
* Arguments
CALL DLASV2( B( 1, 1 ), B( 1, 2 ), B( 2, 2 ), R, T, SNR,
$ CSR, SNL, CSL )
*
-* Form (A,B) := Q(A,B)Z' where Q is left rotation matrix and
+* Form (A,B) := Q(A,B)Z**T where Q is left rotation matrix and
* Z is right rotation matrix computed from DLASV2
*
CALL DROT( 2, A( 1, 1 ), LDA, A( 2, 1 ), LDA, CSL, SNL )
CALL DGEMV( 'NO TRANSPOSE', N-K, I-1, -ONE, Y(K+1,1), LDY,
$ A( K+I-1, 1 ), LDA, ONE, A( K+1, I ), 1 )
*
-* Apply I - V * T' * V**T to this column (call it b) from the
+* Apply I - V * T**T * V**T to this column (call it b) from the
* left, using the last column of T as workspace
*
* Let V = ( V1 ) and b = ( b1 ) (first I-1 rows)
*
* where V1 is unit lower triangular
*
-* w := V1' * b1
+* w := V1**T * b1
*
CALL DCOPY( I-1, A( K+1, I ), 1, T( 1, NB ), 1 )
CALL DTRMV( 'Lower', 'Transpose', 'UNIT',
* [ s*x ]
* xhat = [ c ]
* is an approximate singular vector of
-* [ L 0 ]
-* Lhat = [ w' gamma ]
+* [ 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]' and sestpr**2 is an eigenpair of the system
+* Note that [s c]**T and sestpr**2 is an eigenpair of the system
*
* diag(sest*sest, 0) + [alpha gamma] * [ alpha ]
* [ gamma ]
* =======
*
* DLALN2 solves a system of the form (ca A - w D ) X = s B
-* or (ca A' - w D) X = s B with possible scaling ("s") and
-* perturbation of A. (A' means A-transpose.)
+* 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
*
* 2x2 System
*
-* Compute the real part of C = ca A - w D (or ca A' - w D )
+* Compute the real part of C = ca A - w D (or ca A**T - w D )
*
CR( 1, 1 ) = CA*A( 1, 1 ) - WR*D1
CR( 2, 2 ) = CA*A( 2, 2 ) - WR*D2
* POLES, GIVNUM, and Z.
*
* VT (input) DOUBLE PRECISION array, dimension ( LDU, SMLSIZ+1 ).
-* On entry, VT' contains the right singular vector matrices of
+* On entry, VT**T contains the right singular vector matrices of
* all subproblems at the bottom level.
*
* K (input) INTEGER array, dimension ( N ).
ELSE
* A is xpose
IF( ILU.EQ.0 ) THEN
-* A' is upper
+* A**T is upper
DO J = 1, K - 2
CALL DLASSQ( J, A( 0+( K+J )*LDA ), 1, SCALE, S )
* U at A(0,k)
CALL DLASSQ( K, A( 0+( K-1 )*LDA ), LDA+1, SCALE, S )
* tri L at A(0,k-1)
ELSE
-* A' is lower
+* A**T is lower
DO J = 1, K - 1
CALL DLASSQ( J, A( 0+J*LDA ), 1, SCALE, S )
* U at A(0,0)
ELSE
* A is xpose
IF( ILU.EQ.0 ) THEN
-* A' is upper
+* A**T is upper
DO J = 1, K - 1
CALL DLASSQ( J, A( 0+( K+1+J )*LDA ), 1, SCALE, S )
* U at A(0,k+1)
CALL DLASSQ( K, A( 0+K*LDA ), LDA+1, SCALE, S )
* tri L at A(0,k)
ELSE
-* A' is lower
+* A**T is lower
DO J = 1, K - 1
CALL DLASSQ( J, A( 0+( J+1 )*LDA ), 1, SCALE, S )
* U at A(0,1)
* Auxiliar vector.
*
* F (input/output) DOUBLE PRECISION array, dimension (LDF,NB)
-* Matrix F' = L*Y'*A.
+* Matrix F**T = L*Y**T*A.
*
* LDF (input) INTEGER
* The leading dimension of the array F. LDF >= max(1,N).
CALL DLACPY( 'ALL', KNZ, JLEN, H( INCOL+1+J2, JCOL ),
$ LDH, WH( KZS+1, 1 ), LDWH )
*
-* ==== Multiply by U21' ====
+* ==== Multiply by U21**T ====
*
CALL DLASET( 'ALL', KZS, JLEN, ZERO, ZERO, WH, LDWH )
CALL DTRMM( 'L', 'U', 'C', 'N', KNZ, JLEN, ONE,
$ U( J2+1, 1+KZS ), LDU, WH( KZS+1, 1 ),
$ LDWH )
*
-* ==== Multiply top of H by U11' ====
+* ==== Multiply top of H by U11**T ====
*
CALL DGEMM( 'C', 'N', I2, JLEN, J2, ONE, U, LDU,
$ H( INCOL+1, JCOL ), LDH, ONE, WH, LDWH )
CALL DLACPY( 'ALL', J2, JLEN, H( INCOL+1, JCOL ), LDH,
$ WH( I2+1, 1 ), LDWH )
*
-* ==== Multiply by U21' ====
+* ==== Multiply by U21**T ====
*
CALL DTRMM( 'L', 'L', 'C', 'N', J2, JLEN, ONE,
$ U( 1, I2+1 ), LDU, WH( I2+1, 1 ), LDWH )
* [ . ]
* [ w ]
*
-* op(A) = A or A', A' denotes the conjugate transpose of
+* op(A) = A or A**T, A**T denotes the transpose of
* matrix A.
*
* On input, X = [ c ]. On output, X = [ p ].
*
ELSE
*
-* Solve T'*p = scale*c
+* Solve T**T*p = scale*c
*
JNEXT = 1
DO 40 J = 1, N
LASTV = MAX( K, ILADLR( M, K, V, LDV ) )
LASTC = ILADLC( LASTV, N, C, LDC )
*
-* W := C' * V = (C1**T * V1 + C2**T * V2) (stored in WORK)
+* W := C**T * V = (C1**T * V1 + C2**T * V2) (stored in WORK)
*
* W := C2**T
*
CALL DTRMM( 'Right', 'Lower', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - W * V'
+* C := C - W * V**T
*
IF( LASTV.GT.K ) THEN
*
*
THRESH = DLAMCH('E')
*
-* Compute the first column of B'*B - SIGMA^2*I, up to a scale
+* Compute the first column of B**T*B - SIGMA^2*I, up to a scale
* factor.
*
IF( (SIGMA .EQ. ZERO .AND. ABS(X) .LT. THRESH) .OR.
$ CALL DGEMM( 'Transpose', 'Transpose', N, K, L, ONE,
$ C( M-L+1, 1 ), LDC, V, LDV, ONE, WORK, LDWORK )
*
-* W( 1:n, 1:k ) = W( 1:n, 1:k ) * T' or W( 1:m, 1:k ) * T
+* W( 1:n, 1:k ) = W( 1:n, 1:k ) * T**T or W( 1:m, 1:k ) * T
*
CALL DTRMM( 'Right', 'Lower', TRANST, 'Non-unit', N, K, ONE, T,
$ LDT, WORK, LDWORK )
* 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 = 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 * V
+* H = I - V**T * T * V
*
* Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
*
* On entry, leading dimension of U.
*
* VT (output) DOUBLE PRECISION array, dimension at least (LDVT, M)
-* On exit, VT' contains the right singular vectors.
+* On exit, VT**T contains the right singular vectors.
*
* LDVT (input) INTEGER
* On entry, leading dimension of VT.
*
* DLASD1 computes the SVD as follows:
*
-* ( D1(in) 0 0 0 )
-* B = U(in) * ( Z1' a Z2' b ) * VT(in)
-* ( 0 0 D2(in) 0 )
+* ( 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' = (Z1' a Z2' b) = u' VT', and u is a vector of dimension M
+* 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.
*
* 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' contains the right singular vectors of the
+* VT**T contains the right singular vectors of the
* bidiagonal matrix.
*
* LDVT (input) INTEGER
* The leading dimension of the array U. LDU >= N.
*
* VT (input/output) DOUBLE PRECISION array, dimension(LDVT,M)
-* On entry VT' contains the right singular vectors of two
+* 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' contains the trailing (N-K) updated right singular
+* 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.
* The leading dimension of the array U2. LDU2 >= N.
*
* VT2 (output) DOUBLE PRECISION array, dimension(LDVT2,N)
-* VT2' contains a copy of the first K right singular vectors
+* 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
* The leading dimension of the array U2. LDU2 >= N.
*
* VT (output) DOUBLE PRECISION array, dimension (LDVT, M)
-* The last M - K columns of VT' contain the deflated
+* The last M - K columns of VT**T contain the deflated
* right singular vectors.
*
* LDVT (input) INTEGER
* The leading dimension of the array VT. LDVT >= N.
*
* VT2 (input/output) DOUBLE PRECISION array, dimension (LDVT2, N)
-* The first K columns of VT2' contain the non-deflated
+* The first K columns of VT2**T contain the non-deflated
* right singular vectors for the split problem.
*
* LDVT2 (input) INTEGER
*
* DLASD6 computes the SVD as follows:
*
-* ( D1(in) 0 0 0 )
-* B = U(in) * ( Z1' a Z2' b ) * VT(in)
-* ( 0 0 D2(in) 0 )
+* ( 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' = (Z1' a Z2' b) = u' VT', and u is a vector of dimension M
+* 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.
*
*
* VT (output) DOUBLE PRECISION array,
* dimension ( LDU, SMLSIZ+1 ) if ICOMPQ = 1, and not referenced
-* if ICOMPQ = 0. If ICOMPQ = 1, on exit, VT' contains the right
+* if ICOMPQ = 0. If ICOMPQ = 1, on exit, VT**T contains the right
* singular vector matrices of all subproblems at the bottom
* level.
*
* (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' (P' denotes the transpose
+* 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' * VT if desired.
-* The input matrix C is changed to Q' * C 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,
*
* VT (input/output) DOUBLE PRECISION array, dimension (LDVT, NCVT)
* On entry, contains a matrix which on exit has been
-* premultiplied by P', dimension N-by-NCVT if SQRE = 0
+* 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 (input) INTEGER
*
* C (input/output) DOUBLE PRECISION array, dimension (LDC, NCC)
* On entry, contains an N-by-NCC matrix which on exit
-* has been premultiplied by Q' dimension N-by-NCC if SQRE = 0
+* 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 (input) INTEGER
END IF
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form A * P'
+* Form A * P**T
*
IF( LSAME( PIVOT, 'V' ) ) THEN
IF( LSAME( DIRECT, 'F' ) ) THEN
* 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', where T' denotes the transpose of T.
+* -1. op(T) = T or T**T, where T**T denotes the transpose of T.
*
* Arguments
* =========
* LTRANL (input) LOGICAL
* On entry, LTRANL specifies the op(TL):
* = .FALSE., op(TL) = TL,
-* = .TRUE., op(TL) = TL'.
+* = .TRUE., op(TL) = TL**T.
*
* LTRANR (input) LOGICAL
* On entry, LTRANR specifies the op(TR):
* = .FALSE., op(TR) = TR,
-* = .TRUE., op(TR) = TR'.
+* = .TRUE., op(TR) = TR**T.
*
* ISGN (input) INTEGER
* On entry, ISGN specifies the sign of the equation
*
* DLATBS solves one of the triangular systems
*
-* A *x = s*b or A'*x = s*b
+* 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' denotes the transpose of A, x and b
+* 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
* TRANS (input) CHARACTER*1
* Specifies the operation applied to A.
* = 'N': Solve A * x = s*b (No transpose)
-* = 'T': Solve A'* x = s*b (Transpose)
-* = 'C': Solve A'* x = s*b (Conjugate transpose = Transpose)
+* = 'T': Solve A**T* x = s*b (Transpose)
+* = 'C': Solve A**T* x = s*b (Conjugate transpose = Transpose)
*
* DIAG (input) CHARACTER*1
* Specifies whether or not the matrix A is unit triangular.
*
* SCALE (output) DOUBLE PRECISION
* The scaling factor s for the triangular system
-* A * x = s*b or A'* x = s*b.
+* 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.
*
* prevent overflow, but if the bound overflows, x is set to 0, x(j) to
* 1, and scale to 0, and a non-trivial solution to A*x = 0 is found.
*
-* Similarly, a row-wise scheme is used to solve A'*x = b. The basic
+* Similarly, a row-wise scheme is used to solve A**T*x = b. The basic
* algorithm for A upper triangular is
*
* for j = 1, ..., n
-* x(j) := ( b(j) - A[1:j-1,j]' * x[1:j-1] ) / A(j,j)
+* x(j) := ( b(j) - A[1:j-1,j]**T * x[1:j-1] ) / A(j,j)
* end
*
* We simultaneously compute two bounds
-* G(j) = bound on ( b(i) - A[1:i-1,i]' * x[1:i-1] ), 1<=i<=j
+* G(j) = bound on ( b(i) - A[1:i-1,i]**T * x[1:i-1] ), 1<=i<=j
* M(j) = bound on x(i), 1<=i<=j
*
* The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we
*
ELSE
*
-* Compute the growth in A' * x = b.
+* Compute the growth in A**T * x = b.
*
IF( UPPER ) THEN
JFIRST = 1
*
ELSE
*
-* Solve A' * x = b
+* Solve A**T * x = b
*
DO 160 J = JFIRST, JLAST, JINC
*
ELSE
*
* A(j,j) = 0: Set x(1:n) = 0, x(j) = 1, and
-* scale = 0, and compute a solution to A'*x = 0.
+* scale = 0, and compute a solution to A**T*x = 0.
*
DO 140 I = 1, N
X( I ) = ZERO
*
* DLATPS solves one of the triangular systems
*
-* A *x = s*b or A'*x = s*b
+* 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' denotes the
+* 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
* TRANS (input) CHARACTER*1
* Specifies the operation applied to A.
* = 'N': Solve A * x = s*b (No transpose)
-* = 'T': Solve A'* x = s*b (Transpose)
-* = 'C': Solve A'* x = s*b (Conjugate transpose = Transpose)
+* = 'T': Solve A**T* x = s*b (Transpose)
+* = 'C': Solve A**T* x = s*b (Conjugate transpose = Transpose)
*
* DIAG (input) CHARACTER*1
* Specifies whether or not the matrix A is unit triangular.
*
* SCALE (output) DOUBLE PRECISION
* The scaling factor s for the triangular system
-* A * x = s*b or A'* x = s*b.
+* 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.
*
* prevent overflow, but if the bound overflows, x is set to 0, x(j) to
* 1, and scale to 0, and a non-trivial solution to A*x = 0 is found.
*
-* Similarly, a row-wise scheme is used to solve A'*x = b. The basic
+* Similarly, a row-wise scheme is used to solve A**T*x = b. The basic
* algorithm for A upper triangular is
*
* for j = 1, ..., n
-* x(j) := ( b(j) - A[1:j-1,j]' * x[1:j-1] ) / A(j,j)
+* x(j) := ( b(j) - A[1:j-1,j]**T * x[1:j-1] ) / A(j,j)
* end
*
* We simultaneously compute two bounds
-* G(j) = bound on ( b(i) - A[1:i-1,i]' * x[1:i-1] ), 1<=i<=j
+* G(j) = bound on ( b(i) - A[1:i-1,i]**T * x[1:i-1] ), 1<=i<=j
* M(j) = bound on x(i), 1<=i<=j
*
* The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we
*
ELSE
*
-* Compute the growth in A' * x = b.
+* Compute the growth in A**T * x = b.
*
IF( UPPER ) THEN
JFIRST = 1
*
ELSE
*
-* Solve A' * x = b
+* Solve A**T * x = b
*
IP = JFIRST*( JFIRST+1 ) / 2
JLEN = 1
ELSE
*
* A(j,j) = 0: Set x(1:n) = 0, x(j) = 1, and
-* scale = 0, and compute a solution to A'*x = 0.
+* scale = 0, and compute a solution to A**T*x = 0.
*
DO 140 I = 1, N
X( I ) = ZERO
*
* DLATRS solves one of the triangular systems
*
-* A *x = s*b or A'*x = s*b
+* 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' denotes the transpose of A, x and b are
+* 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
* TRANS (input) CHARACTER*1
* Specifies the operation applied to A.
* = 'N': Solve A * x = s*b (No transpose)
-* = 'T': Solve A'* x = s*b (Transpose)
-* = 'C': Solve A'* x = s*b (Conjugate transpose = Transpose)
+* = 'T': Solve A**T* x = s*b (Transpose)
+* = 'C': Solve A**T* x = s*b (Conjugate transpose = Transpose)
*
* DIAG (input) CHARACTER*1
* Specifies whether or not the matrix A is unit triangular.
*
* SCALE (output) DOUBLE PRECISION
* The scaling factor s for the triangular system
-* A * x = s*b or A'* x = s*b.
+* 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.
*
* prevent overflow, but if the bound overflows, x is set to 0, x(j) to
* 1, and scale to 0, and a non-trivial solution to A*x = 0 is found.
*
-* Similarly, a row-wise scheme is used to solve A'*x = b. The basic
+* Similarly, a row-wise scheme is used to solve A**T*x = b. The basic
* algorithm for A upper triangular is
*
* for j = 1, ..., n
-* x(j) := ( b(j) - A[1:j-1,j]' * x[1:j-1] ) / A(j,j)
+* x(j) := ( b(j) - A[1:j-1,j]**T * x[1:j-1] ) / A(j,j)
* end
*
* We simultaneously compute two bounds
-* G(j) = bound on ( b(i) - A[1:i-1,i]' * x[1:i-1] ), 1<=i<=j
+* G(j) = bound on ( b(i) - A[1:i-1,i]**T * x[1:i-1] ), 1<=i<=j
* M(j) = bound on x(i), 1<=i<=j
*
* The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we
*
ELSE
*
-* Compute the growth in A' * x = b.
+* Compute the growth in A**T * x = b.
*
IF( UPPER ) THEN
JFIRST = 1
*
ELSE
*
-* Solve A' * x = b
+* Solve A**T * x = b
*
DO 160 J = JFIRST, JLAST, JINC
*
ELSE
*
* A(j,j) = 0: Set x(1:n) = 0, x(j) = 1, and
-* scale = 0, and compute a solution to A'*x = 0.
+* scale = 0, and compute a solution to A**T*x = 0.
*
DO 140 I = 1, N
X( I ) = ZERO
END IF
ELSE
*
-* Form P', determined by a call to DGEBRD to reduce a k-by-n
+* Form P**T, determined by a call to DGEBRD to reduce a k-by-n
* matrix
*
IF( K.LT.N ) THEN
* If k >= n, assume m = n
*
* Shift the vectors which define the elementary reflectors one
-* row downward, and set the first row and column of P' to
+* row downward, and set the first row and column of P**T to
* those of the unit matrix
*
A( 1, 1 ) = ONE
60 CONTINUE
IF( N.GT.1 ) THEN
*
-* Form P'(2:n,2:n)
+* Form P**T(2:n,2:n)
*
CALL DORGLQ( N-1, N-1, N-1, A( 2, 2 ), LDA, TAU, WORK,
$ LWORK, IINFO )
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL DPBTRS( UPLO, N, KD, 1, AFB, LDAFB, WORK( N+1 ), N,
$ INFO )
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL DPOTRS( UPLO, N, 1, AF, LDAF, WORK( N+1 ), N, INFO )
DO 110 I = 1, N
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL DPPTRS( UPLO, N, 1, AFP, WORK( N+1 ), N, INFO )
DO 110 I = 1, N
* pivoting of a real symmetric positive semidefinite matrix A.
*
* The factorization has the form
-* P' * A * P = U' * U , if UPLO = 'U',
-* P' * A * P = L * L', if UPLO = 'L',
+* 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.
*
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization P' * A * P = U' * U
+* Compute the Cholesky factorization P**T * A * P = U**T * U
*
DO 130 J = 1, N
*
*
ELSE
*
-* Compute the Cholesky factorization P' * A * P = L * L'
+* Compute the Cholesky factorization P**T * A * P = L * L**T
*
DO 150 J = 1, N
*
* pivoting of a real symmetric positive semidefinite matrix A.
*
* The factorization has the form
-* P' * A * P = U' * U , if UPLO = 'U',
-* P' * A * P = L * L', if UPLO = 'L',
+* 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.
*
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization P' * A * P = U' * U
+* Compute the Cholesky factorization P**T * A * P = U**T * U
*
DO 140 K = 1, N, NB
*
*
ELSE
*
-* Compute the Cholesky factorization P' * A * P = L * L'
+* Compute the Cholesky factorization P**T * A * P = L * L**T
*
DO 180 K = 1, N, NB
*
* m(i,j) = abs(A(i,j)), i = j,
* m(i,j) = -abs(A(i,j)), i .ne. j,
*
-* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**T.
+* and e = [ 1, 1, ..., 1 ]**T. Note M(A) = M(L)*D*M(L)**T.
*
* Solve M(L) * x = e.
*
* m(i,j) = abs(A(i,j)), i = j,
* m(i,j) = -abs(A(i,j)), i .ne. j,
*
-* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**T.
+* and e = [ 1, 1, ..., 1 ]**T. Note M(A) = M(L)*D*M(L)**T.
*
* Solve M(L) * x = e.
*
*
* DSFRK performs one of the symmetric rank--k operations
*
-* C := alpha*A*A' + beta*C,
+* C := alpha*A*A**T + beta*C,
*
* or
*
-* C := alpha*A'*A + beta*C,
+* 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
* On entry, TRANS specifies the operation to be performed as
* follows:
*
-* TRANS = 'N' or 'n' C := alpha*A*A' + beta*C.
+* TRANS = 'N' or 'n' C := alpha*A*A**T + beta*C.
*
-* TRANS = 'T' or 't' C := alpha*A'*A + beta*C.
+* TRANS = 'T' or 't' C := alpha*A**T*A + beta*C.
*
* Unchanged on exit.
*
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL DSPTRS( UPLO, N, 1, AFP, IPIV, WORK( N+1 ), N,
$ INFO )
CALL DAXPY( N-I, ALPHA, AP( II+1 ), 1, TAU( I ), 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v**T
+* A := A - v * w**T - w * v**T
*
CALL DSPR2( UPLO, N-I, -ONE, AP( II+1 ), 1, TAU( I ), 1,
$ AP( I1I1 ) )
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL DSYTRS( UPLO, N, 1, AF, LDAF, IPIV, WORK( N+1 ), N,
$ INFO )
CALL DAXPY( N-I, ALPHA, A( I+1, I ), 1, TAU( I ), 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v**T
+* A := A - v * w**T - w * v**T
*
CALL DSYR2( UPLO, N-I, -ONE, A( I+1, I ), 1, TAU( I ), 1,
$ A( I+1, I+1 ), LDA )
$ LDWORK )
*
* Update the unreduced submatrix A(1:i-1,1:i-1), using an
-* update of the form: A := A - V*W' - W*V**T
+* update of the form: A := A - V*W**T - W*V**T
*
CALL DSYR2K( UPLO, 'No transpose', I-1, NB, -ONE, A( 1, I ),
$ LDA, WORK, LDWORK, ONE, A, LDA )
$ TAU( I ), WORK, LDWORK )
*
* Update the unreduced submatrix A(i+ib:n,i+ib:n), using
-* an update of the form: A := A - V*W' - W*V**T
+* an update of the form: A := A - V*W**T - W*V**T
*
CALL DSYR2K( UPLO, 'No transpose', N-I-NB+1, NB, -ONE,
$ A( I+NB, I ), LDA, WORK( NB+1 ), LDWORK, ONE,
IF( UPPER ) THEN
*
-* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P**T.
*
CALL DTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* U11T*invD1*U11->U11
+* U11**T*invD1*U11->U11
*
CALL DTRMM('L','U','T','U',NNB, NNB,
$ ONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
END DO
END DO
*
-* U01'invD*U01->A(CUT+I,CUT+J)
+* U01**T*invD*U01->A(CUT+I,CUT+J)
*
CALL DGEMM('T','N',NNB,NNB,CUT,ONE,A(1,CUT+1),LDA,
$ WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* U11 = U11T*invD1*U11 + U01'invD*U01
+* U11 = U11**T*invD1*U11 + U01**T*invD*U01
*
DO I=1,NNB
DO J=I,NNB
END DO
END DO
*
-* U01 = U00T*invD0*U01
+* U01 = U00**T*invD0*U01
*
CALL DTRMM('L',UPLO,'T','U',CUT, NNB,
$ ONE,A,LDA,WORK,N+NB+1)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**T: P * inv(U**T)*inv(D)*inv(U) *P**T
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P**T.
*
CALL DTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* L11T*invD1*L11->L11
+* L11**T*invD1*L11->L11
*
CALL DTRMM('L',UPLO,'T','U',NNB, NNB,
$ ONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
*
IF ( (CUT+NNB) .LT. N ) THEN
*
-* L21T*invD2*L21->A(CUT+I,CUT+J)
+* L21**T*invD2*L21->A(CUT+I,CUT+J)
*
CALL DGEMM('T','N',NNB,NNB,N-NNB-CUT,ONE,A(CUT+NNB+1,CUT+1)
$ ,LDA,WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* L11 = L11T*invD1*L11 + U01'invD*U01
+* L11 = L11**T*invD1*L11 + U01**T*invD*U01
*
DO I=1,NNB
DO J=1,I
END DO
END DO
*
-* L01 = L22T*invD2*L21
+* L01 = L22**T*invD2*L21
*
CALL DTRMM('L',UPLO,'T','U', N-NNB-CUT, NNB,
$ ONE,A(CUT+NNB+1,CUT+NNB+1),LDA,WORK,N+NB+1)
ELSE
*
-* L11 = L11T*invD1*L11
+* L11 = L11**T*invD1*L11
*
DO I=1,NNB
DO J=1,I
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**T: P * inv(U**T)*inv(D)*inv(U) *P**T
*
I=N
DO WHILE ( I .GE. 1 )
$ AB, LDAB, WORK, SCALE, WORK( 2*N+1 ), INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**T).
*
CALL DLATBS( UPLO, 'Transpose', DIAG, NORMIN, N, KD, AB,
$ LDAB, WORK, SCALE, WORK( 2*N+1 ), INFO )
DO 250 J = 1, NRHS
*
* Compute residual R = B - op(A) * X,
-* where op(A) = A or A', depending on TRANS.
+* where op(A) = A or A**T, depending on TRANS.
*
CALL DCOPY( N, X( 1, J ), 1, WORK( N+1 ), 1 )
CALL DTBMV( UPLO, TRANS, DIAG, N, KD, AB, LDAB, WORK( N+1 ),
END IF
ELSE
*
-* Compute abs(A')*abs(X) + abs(B).
+* Compute abs(A**T)*abs(X) + abs(B).
*
IF( UPPER ) THEN
IF( NOUNIT ) THEN
END IF
INFO = 0
*
-* Solve A * X = B or A' * X = B.
+* Solve A * X = B or A**T * X = B.
*
DO 30 J = 1, NRHS
CALL DTBSV( UPLO, TRANS, DIAG, N, KD, AB, LDAB, B( 1, J ), 1 )
* 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'.
+* op( A ) = A or op( A ) = A**T.
*
* A is in Rectangular Full Packed (RFP) Format.
*
* 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',
+* (A, B) = Q * (A, B) * Z**T,
*
* so that the diagonal block of (A, B) with row index IFST is moved
* to row ILST.
* ( 0 A22),( 0 B22) n2
* n1 n2 n1 n2
*
-* where N = n1+n2 and U' means the transpose of U. The first n1 columns
+* where N = n1+n2 and U**T means the transpose of U. The first n1 columns
* of U and W span the specified pair of left and right eigenspaces
* (deflating subspaces) of (A, B).
*
*
* U1**T *A13*Q1 = C1*R1; V1**T *B13*Q1 = S1*R1,
*
-* where U1, V1 and Q1 are orthogonal matrix, and Z' is the transpose
+* where U1, V1 and Q1 are orthogonal matrix, and Z**T is the transpose
* of Z. C1 and S1 are diagonal matrices satisfying
*
* C1**2 + S1**2 = I,
* 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' denotes the transpose of Z.
+* 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
* and d2 is an upper bound on Difl((S11, T11), (S22, T22)), i.e. an
* upper bound on sigma-min(Z2), where Z2 is (2n-2)-by-(2n-2)
*
-* Z2 = [ kron(S11', In-2) -kron(I2, S22) ]
-* [ kron(T11', In-2) -kron(I2, T22) ]
+* Z2 = [ kron(S11**T, In-2) -kron(I2, S22) ]
+* [ kron(T11**T, In-2) -kron(I2, T22) ]
*
* Note that if the default method for computing DIF is wanted (see
* DLATDF), then the parameter DIFDRI (see below) should be changed
* In matrix notation solving equation (1) corresponds to solve
* Z*x = scale*b, where Z is defined as
*
-* Z = [ kron(In, A) -kron(B', Im) ] (2)
-* [ kron(In, D) -kron(E', Im) ],
+* 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' is the transpose of X.
+* 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'*y = scale*b for y,
+* 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' * R + D' * L = scale * C (3)
-* R * B' + L * E' = scale * -F
+* 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.
ZDIM = MB*NB*2
IF( ( MB.EQ.1 ) .AND. ( NB.EQ.1 ) ) THEN
*
-* Build a 2-by-2 system Z' * x = RHS
+* Build a 2-by-2 system Z**T * x = RHS
*
Z( 1, 1 ) = A( IS, IS )
Z( 2, 1 ) = -B( JS, JS )
RHS( 1 ) = C( IS, JS )
RHS( 2 ) = F( IS, JS )
*
-* Solve Z' * x = RHS
+* Solve Z**T * x = RHS
*
CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
IF( IERR.GT.0 )
*
ELSE IF( ( MB.EQ.1 ) .AND. ( NB.EQ.2 ) ) THEN
*
-* Build a 4-by-4 system Z' * x = RHS
+* Build a 4-by-4 system Z**T * x = RHS
*
Z( 1, 1 ) = A( IS, IS )
Z( 2, 1 ) = ZERO
RHS( 3 ) = F( IS, JS )
RHS( 4 ) = F( IS, JSP1 )
*
-* Solve Z' * x = RHS
+* Solve Z**T * x = RHS
*
CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
IF( IERR.GT.0 )
*
ELSE IF( ( MB.EQ.2 ) .AND. ( NB.EQ.1 ) ) THEN
*
-* Build a 4-by-4 system Z' * x = RHS
+* Build a 4-by-4 system Z**T * x = RHS
*
Z( 1, 1 ) = A( IS, IS )
Z( 2, 1 ) = A( IS, ISP1 )
RHS( 3 ) = F( IS, JS )
RHS( 4 ) = F( ISP1, JS )
*
-* Solve Z' * x = RHS
+* Solve Z**T * x = RHS
*
CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
IF( IERR.GT.0 )
*
ELSE IF( ( MB.EQ.2 ) .AND. ( NB.EQ.2 ) ) THEN
*
-* Build an 8-by-8 system Z' * x = RHS
+* Build an 8-by-8 system Z**T * x = RHS
*
CALL DLASET( 'F', LDZ, LDZ, ZERO, ZERO, Z, LDZ )
*
160 CONTINUE
*
*
-* Solve Z' * x = RHS
+* Solve Z**T * x = RHS
*
CALL DGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
IF( IERR.GT.0 )
* In matrix notation (1) is equivalent to solve Zx = scale b, where
* Z is defined as
*
-* Z = [ kron(In, A) -kron(B', Im) ] (2)
-* [ kron(In, D) -kron(E', Im) ].
+* 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' is the transpose of
+* 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,
$ WORK, SCALE, WORK( 2*N+1 ), INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**T).
*
CALL DLATPS( UPLO, 'Transpose', DIAG, NORMIN, N, AP,
$ WORK, SCALE, WORK( 2*N+1 ), INFO )
DO 250 J = 1, NRHS
*
* Compute residual R = B - op(A) * X,
-* where op(A) = A or A', depending on TRANS.
+* where op(A) = A or A**T, depending on TRANS.
*
CALL DCOPY( N, X( 1, J ), 1, WORK( N+1 ), 1 )
CALL DTPMV( UPLO, TRANS, DIAG, N, AP, WORK( N+1 ), 1 )
END IF
ELSE
*
-* Compute abs(A')*abs(X) + abs(B).
+* Compute abs(A**T)*abs(X) + abs(B).
*
IF( UPPER ) THEN
KC = 1
END IF
INFO = 0
*
-* Solve A * x = b or A' * x = b.
+* Solve A * x = b or A**T * x = b.
*
DO 30 J = 1, NRHS
CALL DTPSV( UPLO, TRANS, DIAG, N, AP, B( 1, J ), 1 )
$ LDA, WORK, SCALE, WORK( 2*N+1 ), INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**T).
*
CALL DLATRS( UPLO, 'Transpose', DIAG, NORMIN, N, A, LDA,
$ WORK, SCALE, WORK( 2*N+1 ), INFO )
$ WORK( KI+1+N ), 1 )
*
* Solve
-* [T(J,J)-WR T(J,J+1) ]'* X = SCALE*( WORK1 )
-* [T(J+1,J) T(J+1,J+1)-WR] ( WORK2 )
+* [T(J,J)-WR T(J,J+1) ]**T * X = SCALE*( WORK1 )
+* [T(J+1,J) T(J+1,J+1)-WR] ( WORK2 )
*
CALL DLALN2( .TRUE., 2, 1, SMIN, ONE, T( J, J ),
$ LDT, ONE, ONE, WORK( J+N ), N, WR,
$ WORK( KI+2+N2 ), 1 )
*
* Solve 2-by-2 complex linear equation
-* ([T(j,j) T(j,j+1) ]'-(wr-i*wi)*I)*X = SCALE*B
-* ([T(j+1,j) T(j+1,j+1)] )
+* ([T(j,j) T(j,j+1) ]**T-(wr-i*wi)*I)*X = SCALE*B
+* ([T(j+1,j) T(j+1,j+1)] )
*
CALL DLALN2( .TRUE., 2, 2, SMIN, ONE, T( J, J ),
$ LDT, ONE, ONE, WORK( J+N ), N, WR,
DO 250 J = 1, NRHS
*
* Compute residual R = B - op(A) * X,
-* where op(A) = A or A', depending on TRANS.
+* where op(A) = A or A**T, depending on TRANS.
*
CALL DCOPY( N, X( 1, J ), 1, WORK( N+1 ), 1 )
CALL DTRMV( UPLO, TRANS, DIAG, N, A, LDA, WORK( N+1 ), 1 )
END IF
ELSE
*
-* Compute abs(A')*abs(X) + abs(B).
+* Compute abs(A**T)*abs(X) + abs(B).
*
IF( UPPER ) THEN
IF( NOUNIT ) THEN
* ( 0 T22 ) n2
* n1 n2
*
-* where N = n1+n2 and Z' means the transpose of Z. The first n1 columns
+* where N = n1+n2 and Z**T means the transpose of Z. The first n1 columns
* of Z span the specified invariant subspace of T.
*
* If T has been obtained from the real Schur factorization of a matrix
END IF
INFO = 0
*
-* Solve A * x = b or A' * x = b.
+* Solve A * x = b or A**T * x = b.
*
CALL DTRSM( 'Left', UPLO, TRANS, DIAG, N, NRHS, ONE, A, LDA, B,
$ LDB )
*
* VT (output) REAL array, dimension (LDVT,N)
* If COMPQ = 'I', then:
-* On exit, if INFO = 0, VT' contains the right singular
+* 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.
*
* =======
*
* SGBTRS solves a system of linear equations
-* A * X = B or A' * X = B
+* A * X = B or A**T * X = B
* with a general band matrix A using the LU factorization computed
* by SGBTRF.
*
* TRANS (input) CHARACTER*1
* Specifies the form of the system of equations.
* = 'N': A * X = B (No transpose)
-* = 'T': A'* X = B (Transpose)
-* = 'C': A'* X = B (Conjugate transpose = Transpose)
+* = 'T': A**T* X = B (Transpose)
+* = 'C': A**T* X = B (Conjugate transpose = Transpose)
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
ELSE
*
-* Solve A'*X = B.
+* Solve A**T*X = B.
*
DO 30 I = 1, NRHS
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**T*X = B, overwriting B with X.
*
CALL STBSV( 'Upper', 'Transpose', 'Non-unit', N, KL+KU, AB,
$ LDAB, B( 1, I ), 1 )
30 CONTINUE
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**T*X = B, overwriting B with X.
*
IF( LNOTI ) THEN
DO 40 J = N - 1, 1, -1
* =======
*
* SGEBD2 reduces a real general m by n matrix A to upper or lower
-* bidiagonal form B by an orthogonal transformation: Q' * A * P = B.
+* 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.
*
*
ELSE
*
-* Overdetermined system of equations A' * X = B
+* Overdetermined system of equations A**T * X = B
*
-* B(1:N,1:NRHS) := inv(R') * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := inv(R**T) * B(1:N,1:NRHS)
*
CALL STRTRS( 'Upper', 'Transpose', 'Non-unit', N, NRHS,
$ A, LDA, B, LDB, INFO )
*
ELSE
*
-* overdetermined system min || A' * X - B ||
+* overdetermined system min || A**T * X - B ||
*
* B(1:N,1:NRHS) := Q * B(1:N,1:NRHS)
*
*
* workspace at least NRHS, optimally NRHS*NB
*
-* B(1:M,1:NRHS) := inv(L') * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := inv(L**T) * B(1:M,1:NRHS)
*
CALL STRTRS( 'Lower', 'Transpose', 'Non-unit', M, NRHS,
$ A, LDA, B, LDB, INFO )
* L (output) INTEGER
* On exit, K and L specify the dimension of the subblocks
* described in the Purpose section.
-* K + L = effective numerical rank of (A',B')**T.
+* K + L = effective numerical rank of (A**T,B**T)**T.
*
* A (input/output) REAL array, dimension (LDA,N)
* On entry, the M-by-N matrix A.
* TOLA REAL
* TOLB REAL
* TOLA and TOLB are the thresholds to determine the effective
-* rank of (A',B')**T. Generally, they are set to
+* rank of (A**T,B**T)**T. 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
* =======
*
* SGTTRS solves one of the systems of equations
-* A*X = B or A'*X = B,
+* A*X = B or A**T*X = B,
* with a tridiagonal matrix A using the LU factorization computed
* by SGTTRF.
*
* TRANS (input) CHARACTER*1
* Specifies the form of the system of equations.
* = 'N': A * X = B (No transpose)
-* = 'T': A'* X = B (Transpose)
-* = 'C': A'* X = B (Conjugate transpose = Transpose)
+* = 'T': A**T* X = B (Transpose)
+* = 'C': A**T* X = B (Conjugate transpose = Transpose)
*
* N (input) INTEGER
* The order of the matrix A.
* =======
*
* SGTTS2 solves one of the systems of equations
-* A*X = B or A'*X = B,
+* A*X = B or A**T*X = B,
* with a tridiagonal matrix A using the LU factorization computed
* by SGTTRF.
*
* ITRANS (input) INTEGER
* Specifies the form of the system of equations.
* = 0: A * X = B (No transpose)
-* = 1: A'* X = B (Transpose)
-* = 2: A'* X = B (Conjugate transpose = Transpose)
+* = 1: A**T* X = B (Transpose)
+* = 2: A**T* X = B (Conjugate transpose = Transpose)
*
* N (input) INTEGER
* The order of the matrix A.
END IF
ELSE
*
-* Solve A' * X = B.
+* Solve A**T * X = B.
*
IF( NRHS.LE.1 ) THEN
*
-* Solve U'*x = b.
+* Solve U**T*x = b.
*
J = 1
70 CONTINUE
$ B( I-2, J ) ) / D( I )
80 CONTINUE
*
-* Solve L'*x = b.
+* Solve L**T*x = b.
*
DO 90 I = N - 1, 1, -1
IP = IPIV( I )
ELSE
DO 120 J = 1, NRHS
*
-* Solve U'*x = b.
+* Solve U**T*x = b.
*
B( 1, J ) = B( 1, J ) / D( 1 )
IF( N.GT.1 )
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**T).
*
IF ( CMODE .EQ. 1 ) THEN
DO I = 1, N
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**T).
*
IF ( CMODE .EQ. 1 ) THEN
DO I = 1, N
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**T).
*
IF ( CMODE .EQ. 1 ) THEN
DO I = 1, N
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**T).
*
IF ( CMODE .EQ. 1 ) THEN
DO I = 1, N
* X (input/output) REAL array, dimension (N)
* On an intermediate return, X should be overwritten by
* A * X, if KASE=1,
-* A' * X, if KASE=2,
+* A**T * X, if KASE=2,
* and SLACN2 must be re-called with all the other parameters
* unchanged.
*
* KASE (input/output) 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' * X.
+* whether X should be overwritten by A * X or A**T * X.
* On the final return from SLACN2, KASE will again be 0.
*
* ISAVE (input/output) INTEGER array, dimension (3)
* X (input/output) REAL array, dimension (N)
* On an intermediate return, X should be overwritten by
* A * X, if KASE=1,
-* A' * X, if KASE=2,
+* A**T * X, if KASE=2,
* and SLACON must be re-called with all the other parameters
* unchanged.
*
* KASE (input/output) 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' * X.
+* whether X should be overwritten by A * X or A**T * X.
* On the final return from SLACON, KASE will again be 0.
*
* Further Details
* of a full symmetric matrix (which was reduced to tridiagonal form)
* are desired.
*
-* T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)
+* T = Q(in) ( D(in) + RHO * Z*Z**T ) Q**T(in) = Q(out) * D(out) * Q**T(out)
*
-* where Z = Q'u, u is a vector of length N with ones in the
+* 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
VCRIT = BIGNUM
*
* Solve U*(xr,xi) = scale*(vr,vi) for a right eigenvector,
-* or U'*(xr,xi) = scale*(vr,vi) for a left eigenvector,
+* or U**T*(xr,xi) = scale*(vr,vi) for a left eigenvector,
* overwriting (xr,xi) on (vr,vi).
*
DO 250 I = I1, I2, I3
* U = ( CSU SNU ), V = ( CSV SNV ), Q = ( CSQ SNQ )
* ( -SNU CSU ) ( -SNV CSV ) ( -SNQ CSQ )
*
-* Z' denotes the transpose of Z.
+* Z**T denotes the transpose of Z.
*
*
* Arguments
CALL SLASV2( B( 1, 1 ), B( 1, 2 ), B( 2, 2 ), R, T, SNR,
$ CSR, SNL, CSL )
*
-* Form (A,B) := Q(A,B)Z' where Q is left rotation matrix and
+* Form (A,B) := Q(A,B)Z**T where Q is left rotation matrix and
* Z is right rotation matrix computed from SLASV2
*
CALL SROT( 2, A( 1, 1 ), LDA, A( 2, 1 ), LDA, CSL, SNL )
CALL SGEMV( 'NO TRANSPOSE', N-K, I-1, -ONE, Y(K+1,1), LDY,
$ A( K+I-1, 1 ), LDA, ONE, A( K+1, I ), 1 )
*
-* Apply I - V * T' * V**T to this column (call it b) from the
+* Apply I - V * T**T * V**T to this column (call it b) from the
* left, using the last column of T as workspace
*
* Let V = ( V1 ) and b = ( b1 ) (first I-1 rows)
*
* where V1 is unit lower triangular
*
-* w := V1' * b1
+* w := V1**T * b1
*
CALL SCOPY( I-1, A( K+1, I ), 1, T( 1, NB ), 1 )
CALL STRMV( 'Lower', 'Transpose', 'UNIT',
* [ s*x ]
* xhat = [ c ]
* is an approximate singular vector of
-* [ L 0 ]
-* Lhat = [ w' gamma ]
+* [ 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]' and sestpr**2 is an eigenpair of the system
+* Note that [s c]**T and sestpr**2 is an eigenpair of the system
*
* diag(sest*sest, 0) + [alpha gamma] * [ alpha ]
* [ gamma ]
* =======
*
* SLALN2 solves a system of the form (ca A - w D ) X = s B
-* or (ca A' - w D) X = s B with possible scaling ("s") and
-* perturbation of A. (A' means A-transpose.)
+* 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
*
* 2x2 System
*
-* Compute the real part of C = ca A - w D (or ca A' - w D )
+* Compute the real part of C = ca A - w D (or ca A**T - w D )
*
CR( 1, 1 ) = CA*A( 1, 1 ) - WR*D1
CR( 2, 2 ) = CA*A( 2, 2 ) - WR*D2
* POLES, GIVNUM, and Z.
*
* VT (input) REAL array, dimension ( LDU, SMLSIZ+1 ).
-* On entry, VT' contains the right singular vector matrices of
+* On entry, VT**T contains the right singular vector matrices of
* all subproblems at the bottom level.
*
* K (input) INTEGER array, dimension ( N ).
ELSE
* A is xpose
IF( ILU.EQ.0 ) THEN
-* A' is upper
+* A**T is upper
DO J = 1, K - 2
CALL SLASSQ( J, A( 0+( K+J )*LDA ), 1, SCALE, S )
* U at A(0,k)
CALL SLASSQ( K, A( 0+( K-1 )*LDA ), LDA+1, SCALE, S )
* tri L at A(0,k-1)
ELSE
-* A' is lower
+* A**T is lower
DO J = 1, K - 1
CALL SLASSQ( J, A( 0+J*LDA ), 1, SCALE, S )
* U at A(0,0)
ELSE
* A is xpose
IF( ILU.EQ.0 ) THEN
-* A' is upper
+* A**T is upper
DO J = 1, K - 1
CALL SLASSQ( J, A( 0+( K+1+J )*LDA ), 1, SCALE, S )
* U at A(0,k+1)
CALL SLASSQ( K, A( 0+K*LDA ), LDA+1, SCALE, S )
* tri L at A(0,k)
ELSE
-* A' is lower
+* A**T is lower
DO J = 1, K - 1
CALL SLASSQ( J, A( 0+( J+1 )*LDA ), 1, SCALE, S )
* U at A(0,1)
* Auxiliar vector.
*
* F (input/output) REAL array, dimension (LDF,NB)
-* Matrix F' = L*Y'*A.
+* Matrix F**T = L*Y**T*A.
*
* LDF (input) INTEGER
* The leading dimension of the array F. LDF >= max(1,N).
CALL SLACPY( 'ALL', KNZ, JLEN, H( INCOL+1+J2, JCOL ),
$ LDH, WH( KZS+1, 1 ), LDWH )
*
-* ==== Multiply by U21' ====
+* ==== Multiply by U21**T ====
*
CALL SLASET( 'ALL', KZS, JLEN, ZERO, ZERO, WH, LDWH )
CALL STRMM( 'L', 'U', 'C', 'N', KNZ, JLEN, ONE,
$ U( J2+1, 1+KZS ), LDU, WH( KZS+1, 1 ),
$ LDWH )
*
-* ==== Multiply top of H by U11' ====
+* ==== Multiply top of H by U11**T ====
*
CALL SGEMM( 'C', 'N', I2, JLEN, J2, ONE, U, LDU,
$ H( INCOL+1, JCOL ), LDH, ONE, WH, LDWH )
CALL SLACPY( 'ALL', J2, JLEN, H( INCOL+1, JCOL ), LDH,
$ WH( I2+1, 1 ), LDWH )
*
-* ==== Multiply by U21' ====
+* ==== Multiply by U21**T ====
*
CALL STRMM( 'L', 'L', 'C', 'N', J2, JLEN, ONE,
$ U( 1, I2+1 ), LDU, WH( I2+1, 1 ), LDWH )
* [ . ]
* [ w ]
*
-* op(A) = A or A', A' denotes the conjugate transpose of
+* op(A) = A or A**T, A**T denotes the transpose of
* matrix A.
*
* On input, X = [ c ]. On output, X = [ p ].
*
ELSE
*
-* Solve T'*p = scale*c
+* Solve T**T*p = scale*c
*
JNEXT = 1
DO 40 J = 1, N
LASTV = MAX( K, ILASLR( M, K, V, LDV ) )
LASTC = ILASLC( LASTV, N, C, LDC )
*
-* W := C' * V = (C1**T * V1 + C2**T * V2) (stored in WORK)
+* W := C**T * V = (C1**T * V1 + C2**T * V2) (stored in WORK)
*
* W := C2**T
*
CALL STRMM( 'Right', 'Lower', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - W * V'
+* C := C - W * V**T
*
IF( LASTV.GT.K ) THEN
*
*
THRESH = SLAMCH('E')
*
-* Compute the first column of B'*B - SIGMA^2*I, up to a scale
+* Compute the first column of B**T*B - SIGMA^2*I, up to a scale
* factor.
*
IF( (SIGMA .EQ. ZERO .AND. ABS(X) .LT. THRESH) .OR.
$ CALL SGEMM( 'Transpose', 'Transpose', N, K, L, ONE,
$ C( M-L+1, 1 ), LDC, V, LDV, ONE, WORK, LDWORK )
*
-* W( 1:n, 1:k ) = W( 1:n, 1:k ) * T' or W( 1:m, 1:k ) * T
+* W( 1:n, 1:k ) = W( 1:n, 1:k ) * T**T or W( 1:m, 1:k ) * T
*
CALL STRMM( 'Right', 'Lower', TRANST, 'Non-unit', N, K, ONE, T,
$ LDT, WORK, LDWORK )
* 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 = 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 * V
+* H = I - V**T * T * V
*
* Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
*
* On entry, leading dimension of U.
*
* VT (output) REAL array, dimension at least (LDVT, M)
-* On exit, VT' contains the right singular vectors.
+* On exit, VT**T contains the right singular vectors.
*
* LDVT (input) INTEGER
* On entry, leading dimension of VT.
*
* SLASD1 computes the SVD as follows:
*
-* ( D1(in) 0 0 0 )
-* B = U(in) * ( Z1' a Z2' b ) * VT(in)
-* ( 0 0 D2(in) 0 )
+* ( 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' = (Z1' a Z2' b) = u' VT', and u is a vector of dimension M
+* 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.
*
* 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' contains the right singular vectors of the
+* VT**T contains the right singular vectors of the
* bidiagonal matrix.
*
* LDVT (input) INTEGER
* The leading dimension of the array U. LDU >= N.
*
* VT (input/output) REAL array, dimension (LDVT,M)
-* On entry VT' contains the right singular vectors of two
+* 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' contains the trailing (N-K) updated right singular
+* 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.
* The leading dimension of the array U2. LDU2 >= N.
*
* VT2 (output) REAL array, dimension (LDVT2,N)
-* VT2' contains a copy of the first K right singular vectors
+* 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
* The leading dimension of the array U2. LDU2 >= N.
*
* VT (output) REAL array, dimension (LDVT, M)
-* The last M - K columns of VT' contain the deflated
+* The last M - K columns of VT**T contain the deflated
* right singular vectors.
*
* LDVT (input) INTEGER
* The leading dimension of the array VT. LDVT >= N.
*
* VT2 (input/output) REAL array, dimension (LDVT2, N)
-* The first K columns of VT2' contain the non-deflated
+* The first K columns of VT2**T contain the non-deflated
* right singular vectors for the split problem.
*
* LDVT2 (input) INTEGER
*
* SLASD6 computes the SVD as follows:
*
-* ( D1(in) 0 0 0 )
-* B = U(in) * ( Z1' a Z2' b ) * VT(in)
-* ( 0 0 D2(in) 0 )
+* ( 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' = (Z1' a Z2' b) = u' VT', and u is a vector of dimension M
+* 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.
*
*
* VT (output) REAL array,
* dimension ( LDU, SMLSIZ+1 ) if ICOMPQ = 1, and not referenced
-* if ICOMPQ = 0. If ICOMPQ = 1, on exit, VT' contains the right
+* if ICOMPQ = 0. If ICOMPQ = 1, on exit, VT**T contains the right
* singular vector matrices of all subproblems at the bottom
* level.
*
* (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' (P' denotes the transpose
+* 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' * VT if desired.
-* The input matrix C is changed to Q' * C 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,
*
* VT (input/output) REAL array, dimension (LDVT, NCVT)
* On entry, contains a matrix which on exit has been
-* premultiplied by P', dimension N-by-NCVT if SQRE = 0
+* 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 (input) INTEGER
*
* C (input/output) REAL array, dimension (LDC, NCC)
* On entry, contains an N-by-NCC matrix which on exit
-* has been premultiplied by Q' dimension N-by-NCC if SQRE = 0
+* 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 (input) INTEGER
END IF
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form A * P'
+* Form A * P**T
*
IF( LSAME( PIVOT, 'V' ) ) THEN
IF( LSAME( DIRECT, 'F' ) ) THEN
* 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', where T' denotes the transpose of T.
+* -1. op(T) = T or T**T, where T**T denotes the transpose of T.
*
* Arguments
* =========
* LTRANL (input) LOGICAL
* On entry, LTRANL specifies the op(TL):
* = .FALSE., op(TL) = TL,
-* = .TRUE., op(TL) = TL'.
+* = .TRUE., op(TL) = TL**T.
*
* LTRANR (input) LOGICAL
* On entry, LTRANR specifies the op(TR):
* = .FALSE., op(TR) = TR,
-* = .TRUE., op(TR) = TR'.
+* = .TRUE., op(TR) = TR**T.
*
* ISGN (input) INTEGER
* On entry, ISGN specifies the sign of the equation
*
* SLATBS solves one of the triangular systems
*
-* A *x = s*b or A'*x = s*b
+* 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' denotes the transpose of A, x and b
+* 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
* TRANS (input) CHARACTER*1
* Specifies the operation applied to A.
* = 'N': Solve A * x = s*b (No transpose)
-* = 'T': Solve A'* x = s*b (Transpose)
-* = 'C': Solve A'* x = s*b (Conjugate transpose = Transpose)
+* = 'T': Solve A**T* x = s*b (Transpose)
+* = 'C': Solve A**T* x = s*b (Conjugate transpose = Transpose)
*
* DIAG (input) CHARACTER*1
* Specifies whether or not the matrix A is unit triangular.
*
* SCALE (output) REAL
* The scaling factor s for the triangular system
-* A * x = s*b or A'* x = s*b.
+* 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.
*
* prevent overflow, but if the bound overflows, x is set to 0, x(j) to
* 1, and scale to 0, and a non-trivial solution to A*x = 0 is found.
*
-* Similarly, a row-wise scheme is used to solve A'*x = b. The basic
+* Similarly, a row-wise scheme is used to solve A**T*x = b. The basic
* algorithm for A upper triangular is
*
* for j = 1, ..., n
-* x(j) := ( b(j) - A[1:j-1,j]' * x[1:j-1] ) / A(j,j)
+* x(j) := ( b(j) - A[1:j-1,j]**T * x[1:j-1] ) / A(j,j)
* end
*
* We simultaneously compute two bounds
-* G(j) = bound on ( b(i) - A[1:i-1,i]' * x[1:i-1] ), 1<=i<=j
+* G(j) = bound on ( b(i) - A[1:i-1,i]**T * x[1:i-1] ), 1<=i<=j
* M(j) = bound on x(i), 1<=i<=j
*
* The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we
*
ELSE
*
-* Compute the growth in A' * x = b.
+* Compute the growth in A**T * x = b.
*
IF( UPPER ) THEN
JFIRST = 1
*
ELSE
*
-* Solve A' * x = b
+* Solve A**T * x = b
*
DO 140 J = JFIRST, JLAST, JINC
*
ELSE
*
* A(j,j) = 0: Set x(1:n) = 0, x(j) = 1, and
-* scale = 0, and compute a solution to A'*x = 0.
+* scale = 0, and compute a solution to A**T*x = 0.
*
DO 130 I = 1, N
X( I ) = ZERO
*
* SLATPS solves one of the triangular systems
*
-* A *x = s*b or A'*x = s*b
+* 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' denotes the
+* 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
* TRANS (input) CHARACTER*1
* Specifies the operation applied to A.
* = 'N': Solve A * x = s*b (No transpose)
-* = 'T': Solve A'* x = s*b (Transpose)
-* = 'C': Solve A'* x = s*b (Conjugate transpose = Transpose)
+* = 'T': Solve A**T* x = s*b (Transpose)
+* = 'C': Solve A**T* x = s*b (Conjugate transpose = Transpose)
*
* DIAG (input) CHARACTER*1
* Specifies whether or not the matrix A is unit triangular.
*
* SCALE (output) REAL
* The scaling factor s for the triangular system
-* A * x = s*b or A'* x = s*b.
+* 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.
*
* prevent overflow, but if the bound overflows, x is set to 0, x(j) to
* 1, and scale to 0, and a non-trivial solution to A*x = 0 is found.
*
-* Similarly, a row-wise scheme is used to solve A'*x = b. The basic
+* Similarly, a row-wise scheme is used to solve A**T*x = b. The basic
* algorithm for A upper triangular is
*
* for j = 1, ..., n
-* x(j) := ( b(j) - A[1:j-1,j]' * x[1:j-1] ) / A(j,j)
+* x(j) := ( b(j) - A[1:j-1,j]**T * x[1:j-1] ) / A(j,j)
* end
*
* We simultaneously compute two bounds
-* G(j) = bound on ( b(i) - A[1:i-1,i]' * x[1:i-1] ), 1<=i<=j
+* G(j) = bound on ( b(i) - A[1:i-1,i]**T * x[1:i-1] ), 1<=i<=j
* M(j) = bound on x(i), 1<=i<=j
*
* The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we
*
ELSE
*
-* Compute the growth in A' * x = b.
+* Compute the growth in A**T * x = b.
*
IF( UPPER ) THEN
JFIRST = 1
*
ELSE
*
-* Solve A' * x = b
+* Solve A**T * x = b
*
IP = JFIRST*( JFIRST+1 ) / 2
JLEN = 1
ELSE
*
* A(j,j) = 0: Set x(1:n) = 0, x(j) = 1, and
-* scale = 0, and compute a solution to A'*x = 0.
+* scale = 0, and compute a solution to A**T*x = 0.
*
DO 130 I = 1, N
X( I ) = ZERO
*
* SLATRS solves one of the triangular systems
*
-* A *x = s*b or A'*x = s*b
+* 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' denotes the transpose of A, x and b are
+* 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
* TRANS (input) CHARACTER*1
* Specifies the operation applied to A.
* = 'N': Solve A * x = s*b (No transpose)
-* = 'T': Solve A'* x = s*b (Transpose)
-* = 'C': Solve A'* x = s*b (Conjugate transpose = Transpose)
+* = 'T': Solve A**T* x = s*b (Transpose)
+* = 'C': Solve A**T* x = s*b (Conjugate transpose = Transpose)
*
* DIAG (input) CHARACTER*1
* Specifies whether or not the matrix A is unit triangular.
*
* SCALE (output) REAL
* The scaling factor s for the triangular system
-* A * x = s*b or A'* x = s*b.
+* 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.
*
* prevent overflow, but if the bound overflows, x is set to 0, x(j) to
* 1, and scale to 0, and a non-trivial solution to A*x = 0 is found.
*
-* Similarly, a row-wise scheme is used to solve A'*x = b. The basic
+* Similarly, a row-wise scheme is used to solve A**T*x = b. The basic
* algorithm for A upper triangular is
*
* for j = 1, ..., n
-* x(j) := ( b(j) - A[1:j-1,j]' * x[1:j-1] ) / A(j,j)
+* x(j) := ( b(j) - A[1:j-1,j]**T * x[1:j-1] ) / A(j,j)
* end
*
* We simultaneously compute two bounds
-* G(j) = bound on ( b(i) - A[1:i-1,i]' * x[1:i-1] ), 1<=i<=j
+* G(j) = bound on ( b(i) - A[1:i-1,i]**T * x[1:i-1] ), 1<=i<=j
* M(j) = bound on x(i), 1<=i<=j
*
* The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we
*
ELSE
*
-* Compute the growth in A' * x = b.
+* Compute the growth in A**T * x = b.
*
IF( UPPER ) THEN
JFIRST = 1
*
ELSE
*
-* Solve A' * x = b
+* Solve A**T * x = b
*
DO 140 J = JFIRST, JLAST, JINC
*
ELSE
*
* A(j,j) = 0: Set x(1:n) = 0, x(j) = 1, and
-* scale = 0, and compute a solution to A'*x = 0.
+* scale = 0, and compute a solution to A**T*x = 0.
*
DO 130 I = 1, N
X( I ) = ZERO
END IF
ELSE
*
-* Form P', determined by a call to SGEBRD to reduce a k-by-n
+* Form P**T, determined by a call to SGEBRD to reduce a k-by-n
* matrix
*
IF( K.LT.N ) THEN
* If k >= n, assume m = n
*
* Shift the vectors which define the elementary reflectors one
-* row downward, and set the first row and column of P' to
+* row downward, and set the first row and column of P**T to
* those of the unit matrix
*
A( 1, 1 ) = ONE
60 CONTINUE
IF( N.GT.1 ) THEN
*
-* Form P'(2:n,2:n)
+* Form P**T(2:n,2:n)
*
CALL SORGLQ( N-1, N-1, N-1, A( 2, 2 ), LDA, TAU, WORK,
$ LWORK, IINFO )
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL SPBTRS( UPLO, N, KD, 1, AFB, LDAFB, WORK( N+1 ), N,
$ INFO )
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL SPOTRS( UPLO, N, 1, AF, LDAF, WORK( N+1 ), N, INFO )
DO 110 I = 1, N
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL SPPTRS( UPLO, N, 1, AFP, WORK( N+1 ), N, INFO )
DO 110 I = 1, N
* pivoting of a real symmetric positive semidefinite matrix A.
*
* The factorization has the form
-* P' * A * P = U' * U , if UPLO = 'U',
-* P' * A * P = L * L', if UPLO = 'L',
+* 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.
*
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization P' * A * P = U' * U
+* Compute the Cholesky factorization P**T * A * P = U**T * U
*
DO 130 J = 1, N
*
*
ELSE
*
-* Compute the Cholesky factorization P' * A * P = L * L'
+* Compute the Cholesky factorization P**T * A * P = L * L**T
*
DO 150 J = 1, N
*
* pivoting of a real symmetric positive semidefinite matrix A.
*
* The factorization has the form
-* P' * A * P = U' * U , if UPLO = 'U',
-* P' * A * P = L * L', if UPLO = 'L',
+* 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.
*
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization P' * A * P = U' * U
+* Compute the Cholesky factorization P**T * A * P = U**T * U
*
DO 140 K = 1, N, NB
*
*
ELSE
*
-* Compute the Cholesky factorization P' * A * P = L * L'
+* Compute the Cholesky factorization P**T * A * P = L * L**T
*
DO 180 K = 1, N, NB
*
* m(i,j) = abs(A(i,j)), i = j,
* m(i,j) = -abs(A(i,j)), i .ne. j,
*
-* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**T.
+* and e = [ 1, 1, ..., 1 ]**T. Note M(A) = M(L)*D*M(L)**T.
*
* Solve M(L) * x = e.
*
* m(i,j) = abs(A(i,j)), i = j,
* m(i,j) = -abs(A(i,j)), i .ne. j,
*
-* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**T.
+* and e = [ 1, 1, ..., 1 ]**T. Note M(A) = M(L)*D*M(L)**T.
*
* Solve M(L) * x = e.
*
*
* SSFRK performs one of the symmetric rank--k operations
*
-* C := alpha*A*A' + beta*C,
+* C := alpha*A*A**T + beta*C,
*
* or
*
-* C := alpha*A'*A + beta*C,
+* 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
* On entry, TRANS specifies the operation to be performed as
* follows:
*
-* TRANS = 'N' or 'n' C := alpha*A*A' + beta*C.
+* TRANS = 'N' or 'n' C := alpha*A*A**T + beta*C.
*
-* TRANS = 'T' or 't' C := alpha*A'*A + beta*C.
+* TRANS = 'T' or 't' C := alpha*A**T*A + beta*C.
*
* Unchanged on exit.
*
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL SSPTRS( UPLO, N, 1, AFP, IPIV, WORK( N+1 ), N,
$ INFO )
CALL SAXPY( N-I, ALPHA, AP( II+1 ), 1, TAU( I ), 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v**T
+* A := A - v * w**T - w * v**T
*
CALL SSPR2( UPLO, N-I, -ONE, AP( II+1 ), 1, TAU( I ), 1,
$ AP( I1I1 ) )
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL SSYTRS( UPLO, N, 1, AF, LDAF, IPIV, WORK( N+1 ), N,
$ INFO )
CALL SAXPY( N-I, ALPHA, A( I+1, I ), 1, TAU( I ), 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v**T
+* A := A - v * w**T - w * v**T
*
CALL SSYR2( UPLO, N-I, -ONE, A( I+1, I ), 1, TAU( I ), 1,
$ A( I+1, I+1 ), LDA )
$ LDWORK )
*
* Update the unreduced submatrix A(1:i-1,1:i-1), using an
-* update of the form: A := A - V*W' - W*V**T
+* update of the form: A := A - V*W**T - W*V**T
*
CALL SSYR2K( UPLO, 'No transpose', I-1, NB, -ONE, A( 1, I ),
$ LDA, WORK, LDWORK, ONE, A, LDA )
$ TAU( I ), WORK, LDWORK )
*
* Update the unreduced submatrix A(i+ib:n,i+ib:n), using
-* an update of the form: A := A - V*W' - W*V**T
+* an update of the form: A := A - V*W**T - W*V**T
*
CALL SSYR2K( UPLO, 'No transpose', N-I-NB+1, NB, -ONE,
$ A( I+NB, I ), LDA, WORK( NB+1 ), LDWORK, ONE,
IF( UPPER ) THEN
*
-* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P**T.
*
CALL STRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* U11T*invD1*U11->U11
+* U11**T*invD1*U11->U11
*
CALL STRMM('L','U','T','U',NNB, NNB,
$ ONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
END DO
END DO
*
-* U01'invD*U01->A(CUT+I,CUT+J)
+* U01**T*invD*U01->A(CUT+I,CUT+J)
*
CALL SGEMM('T','N',NNB,NNB,CUT,ONE,A(1,CUT+1),LDA,
$ WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* U11 = U11T*invD1*U11 + U01'invD*U01
+* U11 = U11**T*invD1*U11 + U01**T*invD*U01
*
DO I=1,NNB
DO J=I,NNB
END DO
END DO
*
-* U01 = U00T*invD0*U01
+* U01 = U00**T*invD0*U01
*
CALL STRMM('L',UPLO,'T','U',CUT, NNB,
$ ONE,A,LDA,WORK,N+NB+1)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**T: P * inv(U**T)*inv(D)*inv(U) *P**T
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P**T.
*
CALL STRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* L11T*invD1*L11->L11
+* L11**T*invD1*L11->L11
*
CALL STRMM('L',UPLO,'T','U',NNB, NNB,
$ ONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
*
IF ( (CUT+NNB) .LT. N ) THEN
*
-* L21T*invD2*L21->A(CUT+I,CUT+J)
+* L21**T*invD2*L21->A(CUT+I,CUT+J)
*
CALL SGEMM('T','N',NNB,NNB,N-NNB-CUT,ONE,A(CUT+NNB+1,CUT+1)
$ ,LDA,WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* L11 = L11T*invD1*L11 + U01'invD*U01
+* L11 = L11**T*invD1*L11 + U01**T*invD*U01
*
DO I=1,NNB
DO J=1,I
END DO
END DO
*
-* L01 = L22T*invD2*L21
+* L01 = L22**T*invD2*L21
*
CALL STRMM('L',UPLO,'T','U', N-NNB-CUT, NNB,
$ ONE,A(CUT+NNB+1,CUT+NNB+1),LDA,WORK,N+NB+1)
ELSE
*
-* L11 = L11T*invD1*L11
+* L11 = L11**T*invD1*L11
*
DO I=1,NNB
DO J=1,I
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**T: P * inv(U**T)*inv(D)*inv(U) *P**T
*
I=N
DO WHILE ( I .GE. 1 )
*
* Solve A*X = B, where A = U*D*U**T.
*
-* P' * B
+* P**T * B
K=N
DO WHILE ( K .GE. 1 )
IF( IPIV( K ).GT.0 ) THEN
*
* Solve A*X = B, where A = L*D*L**T.
*
-* P' * B
+* P**T * B
K=1
DO WHILE ( K .LE. N )
IF( IPIV( K ).GT.0 ) THEN
$ AB, LDAB, WORK, SCALE, WORK( 2*N+1 ), INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**T).
*
CALL SLATBS( UPLO, 'Transpose', DIAG, NORMIN, N, KD, AB,
$ LDAB, WORK, SCALE, WORK( 2*N+1 ), INFO )
DO 250 J = 1, NRHS
*
* Compute residual R = B - op(A) * X,
-* where op(A) = A or A', depending on TRANS.
+* where op(A) = A or A**T, depending on TRANS.
*
CALL SCOPY( N, X( 1, J ), 1, WORK( N+1 ), 1 )
CALL STBMV( UPLO, TRANS, DIAG, N, KD, AB, LDAB, WORK( N+1 ),
END IF
ELSE
*
-* Compute abs(A')*abs(X) + abs(B).
+* Compute abs(A**T)*abs(X) + abs(B).
*
IF( UPPER ) THEN
IF( NOUNIT ) THEN
END IF
INFO = 0
*
-* Solve A * X = B or A' * X = B.
+* Solve A * X = B or A**T * X = B.
*
DO 30 J = 1, NRHS
CALL STBSV( UPLO, TRANS, DIAG, N, KD, AB, LDAB, B( 1, J ), 1 )
* 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'.
+* op( A ) = A or op( A ) = A**T.
*
* A is in Rectangular Full Packed (RFP) Format.
*
* 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',
+* (A, B) = Q * (A, B) * Z**T,
*
* so that the diagonal block of (A, B) with row index IFST is moved
* to row ILST.
* ( 0 A22),( 0 B22) n2
* n1 n2 n1 n2
*
-* where N = n1+n2 and U' means the transpose of U. The first n1 columns
+* where N = n1+n2 and U**T means the transpose of U. The first n1 columns
* of U and W span the specified pair of left and right eigenspaces
* (deflating subspaces) of (A, B).
*
*
* U1**T *A13*Q1 = C1*R1; V1**T *B13*Q1 = S1*R1,
*
-* where U1, V1 and Q1 are orthogonal matrix, and Z' is the transpose
+* where U1, V1 and Q1 are orthogonal matrix, and Z**T is the transpose
* of Z. C1 and S1 are diagonal matrices satisfying
*
* C1**2 + S1**2 = I,
* 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' denotes the transpose of Z.
+* 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
* and d2 is an upper bound on Difl((S11, T11), (S22, T22)), i.e. an
* upper bound on sigma-min(Z2), where Z2 is (2n-2)-by-(2n-2)
*
-* Z2 = [ kron(S11', In-2) -kron(I2, S22) ]
-* [ kron(T11', In-2) -kron(I2, T22) ]
+* Z2 = [ kron(S11**T, In-2) -kron(I2, S22) ]
+* [ kron(T11**T, In-2) -kron(I2, T22) ]
*
* Note that if the default method for computing DIF is wanted (see
* SLATDF), then the parameter DIFDRI (see below) should be changed
* In matrix notation solving equation (1) corresponds to solve
* Z*x = scale*b, where Z is defined as
*
-* Z = [ kron(In, A) -kron(B', Im) ] (2)
-* [ kron(In, D) -kron(E', Im) ],
+* 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' is the transpose of X.
+* 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'*y = scale*b for y,
+* 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' * R + D' * L = scale * C (3)
-* R * B' + L * E' = scale * -F
+* 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.
ZDIM = MB*NB*2
IF( ( MB.EQ.1 ) .AND. ( NB.EQ.1 ) ) THEN
*
-* Build a 2-by-2 system Z' * x = RHS
+* Build a 2-by-2 system Z**T * x = RHS
*
Z( 1, 1 ) = A( IS, IS )
Z( 2, 1 ) = -B( JS, JS )
RHS( 1 ) = C( IS, JS )
RHS( 2 ) = F( IS, JS )
*
-* Solve Z' * x = RHS
+* Solve Z**T * x = RHS
*
CALL SGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
IF( IERR.GT.0 )
*
ELSE IF( ( MB.EQ.1 ) .AND. ( NB.EQ.2 ) ) THEN
*
-* Build a 4-by-4 system Z' * x = RHS
+* Build a 4-by-4 system Z**T * x = RHS
*
Z( 1, 1 ) = A( IS, IS )
Z( 2, 1 ) = ZERO
RHS( 3 ) = F( IS, JS )
RHS( 4 ) = F( IS, JSP1 )
*
-* Solve Z' * x = RHS
+* Solve Z**T * x = RHS
*
CALL SGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
IF( IERR.GT.0 )
*
ELSE IF( ( MB.EQ.2 ) .AND. ( NB.EQ.1 ) ) THEN
*
-* Build a 4-by-4 system Z' * x = RHS
+* Build a 4-by-4 system Z**T * x = RHS
*
Z( 1, 1 ) = A( IS, IS )
Z( 2, 1 ) = A( IS, ISP1 )
RHS( 3 ) = F( IS, JS )
RHS( 4 ) = F( ISP1, JS )
*
-* Solve Z' * x = RHS
+* Solve Z**T * x = RHS
*
CALL SGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
IF( IERR.GT.0 )
*
ELSE IF( ( MB.EQ.2 ) .AND. ( NB.EQ.2 ) ) THEN
*
-* Build an 8-by-8 system Z' * x = RHS
+* Build an 8-by-8 system Z**T * x = RHS
*
CALL SLASET( 'F', LDZ, LDZ, ZERO, ZERO, Z, LDZ )
*
160 CONTINUE
*
*
-* Solve Z' * x = RHS
+* Solve Z**T * x = RHS
*
CALL SGETC2( ZDIM, Z, LDZ, IPIV, JPIV, IERR )
IF( IERR.GT.0 )
* In matrix notation (1) is equivalent to solve Zx = scale b, where
* Z is defined as
*
-* Z = [ kron(In, A) -kron(B', Im) ] (2)
-* [ kron(In, D) -kron(E', Im) ].
+* 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' is the transpose of
+* 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,
$ WORK, SCALE, WORK( 2*N+1 ), INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**T).
*
CALL SLATPS( UPLO, 'Transpose', DIAG, NORMIN, N, AP,
$ WORK, SCALE, WORK( 2*N+1 ), INFO )
DO 250 J = 1, NRHS
*
* Compute residual R = B - op(A) * X,
-* where op(A) = A or A', depending on TRANS.
+* where op(A) = A or A**T, depending on TRANS.
*
CALL SCOPY( N, X( 1, J ), 1, WORK( N+1 ), 1 )
CALL STPMV( UPLO, TRANS, DIAG, N, AP, WORK( N+1 ), 1 )
END IF
ELSE
*
-* Compute abs(A')*abs(X) + abs(B).
+* Compute abs(A**T)*abs(X) + abs(B).
*
IF( UPPER ) THEN
KC = 1
END IF
INFO = 0
*
-* Solve A * x = b or A' * x = b.
+* Solve A * x = b or A**T * x = b.
*
DO 30 J = 1, NRHS
CALL STPSV( UPLO, TRANS, DIAG, N, AP, B( 1, J ), 1 )
$ LDA, WORK, SCALE, WORK( 2*N+1 ), INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**T).
*
CALL SLATRS( UPLO, 'Transpose', DIAG, NORMIN, N, A, LDA,
$ WORK, SCALE, WORK( 2*N+1 ), INFO )
$ WORK( KI+1+N ), 1 )
*
* Solve
-* [T(J,J)-WR T(J,J+1) ]'* X = SCALE*( WORK1 )
-* [T(J+1,J) T(J+1,J+1)-WR] ( WORK2 )
+* [T(J,J)-WR T(J,J+1) ]**T* X = SCALE*( WORK1 )
+* [T(J+1,J) T(J+1,J+1)-WR] ( WORK2 )
*
CALL SLALN2( .TRUE., 2, 1, SMIN, ONE, T( J, J ),
$ LDT, ONE, ONE, WORK( J+N ), N, WR,
$ WORK( KI+2+N2 ), 1 )
*
* Solve 2-by-2 complex linear equation
-* ([T(j,j) T(j,j+1) ]'-(wr-i*wi)*I)*X = SCALE*B
-* ([T(j+1,j) T(j+1,j+1)] )
+* ([T(j,j) T(j,j+1) ]**T-(wr-i*wi)*I)*X = SCALE*B
+* ([T(j+1,j) T(j+1,j+1)] )
*
CALL SLALN2( .TRUE., 2, 2, SMIN, ONE, T( J, J ),
$ LDT, ONE, ONE, WORK( J+N ), N, WR,
DO 250 J = 1, NRHS
*
* Compute residual R = B - op(A) * X,
-* where op(A) = A or A', depending on TRANS.
+* where op(A) = A or A**T, depending on TRANS.
*
CALL SCOPY( N, X( 1, J ), 1, WORK( N+1 ), 1 )
CALL STRMV( UPLO, TRANS, DIAG, N, A, LDA, WORK( N+1 ), 1 )
END IF
ELSE
*
-* Compute abs(A')*abs(X) + abs(B).
+* Compute abs(A**T)*abs(X) + abs(B).
*
IF( UPPER ) THEN
IF( NOUNIT ) THEN
* ( 0 T22 ) n2
* n1 n2
*
-* where N = n1+n2 and Z' means the transpose of Z. The first n1 columns
+* where N = n1+n2 and Z**T means the transpose of Z. The first n1 columns
* of Z span the specified invariant subspace of T.
*
* If T has been obtained from the real Schur factorization of a matrix
END IF
INFO = 0
*
-* Solve A * x = b or A' * x = b.
+* Solve A * x = b or A**T * x = b.
*
CALL STRSM( 'Left', UPLO, TRANS, DIAG, N, NRHS, ONE, A, LDA, B,
$ LDB )
*
ELSE
*
-* Overdetermined system of equations A' * X = B
+* Overdetermined system of equations A**H * X = B
*
-* B(1:N,1:NRHS) := inv(R') * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := inv(R**H) * B(1:N,1:NRHS)
*
CALL ZTRTRS( 'Upper', 'Conjugate transpose','Non-unit',
$ N, NRHS, A, LDA, B, LDB, INFO )
*
ELSE
*
-* overdetermined system min || A' * X - B ||
+* overdetermined system min || A**H * X - B ||
*
* B(1:N,1:NRHS) := Q * B(1:N,1:NRHS)
*
*
* workspace at least NRHS, optimally NRHS*NB
*
-* B(1:M,1:NRHS) := inv(L') * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := inv(L**H) * B(1:M,1:NRHS)
*
CALL ZTRTRS( 'Lower', 'Conjugate transpose', 'Non-unit',
$ M, NRHS, A, LDA, B, LDB, INFO )
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**H).
*
CALL ZHETRS( UPLO, N, 1, AF, LDAF, IPIV, WORK, N, INFO )
DO 110 I = 1, N
CALL ZAXPY( N-I, ALPHA, A( I+1, I ), 1, TAU( I ), 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v**H
+* A := A - v * w**H - w * v**H
*
CALL ZHER2( UPLO, N-I, -ONE, A( I+1, I ), 1, TAU( I ), 1,
$ A( I+1, I+1 ), LDA )
$ LDWORK )
*
* Update the unreduced submatrix A(1:i-1,1:i-1), using an
-* update of the form: A := A - V*W' - W*V**H
+* update of the form: A := A - V*W**H - W*V**H
*
CALL ZHER2K( UPLO, 'No transpose', I-1, NB, -CONE,
$ A( 1, I ), LDA, WORK, LDWORK, ONE, A, LDA )
$ TAU( I ), WORK, LDWORK )
*
* Update the unreduced submatrix A(i+nb:n,i+nb:n), using
-* an update of the form: A := A - V*W' - W*V**H
+* an update of the form: A := A - V*W**H - W*V**H
*
CALL ZHER2K( UPLO, 'No transpose', N-I-NB+1, NB, -CONE,
$ A( I+NB, I ), LDA, WORK( NB+1 ), LDWORK, ONE,
IF( UPPER ) THEN
*
-* invA = P * inv(U**H)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**H)*inv(D)*inv(U)*P**H.
*
CALL ZTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* U11T*invD1*U11->U11
+* U11**H*invD1*U11->U11
*
CALL ZTRMM('L','U','C','U',NNB, NNB,
$ CONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
END DO
END DO
*
-* U01'invD*U01->A(CUT+I,CUT+J)
+* U01**H*invD*U01->A(CUT+I,CUT+J)
*
CALL ZGEMM('C','N',NNB,NNB,CUT,CONE,A(1,CUT+1),LDA,
$ WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* U11 = U11T*invD1*U11 + U01'invD*U01
+* U11 = U11**H*invD1*U11 + U01**H*invD*U01
*
DO I=1,NNB
DO J=I,NNB
END DO
END DO
*
-* U01 = U00T*invD0*U01
+* U01 = U00**H*invD0*U01
*
CALL ZTRMM('L',UPLO,'C','U',CUT, NNB,
$ CONE,A,LDA,WORK,N+NB+1)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**H)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**H: P * inv(U**H)*inv(D)*inv(U) *P**H
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U**H)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**H)*inv(D)*inv(U)*P**H.
*
CALL ZTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* L11T*invD1*L11->L11
+* L11**H*invD1*L11->L11
*
CALL ZTRMM('L',UPLO,'C','U',NNB, NNB,
$ CONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
*
IF ( (CUT+NNB) .LT. N ) THEN
*
-* L21T*invD2*L21->A(CUT+I,CUT+J)
+* L21**H*invD2*L21->A(CUT+I,CUT+J)
*
CALL ZGEMM('C','N',NNB,NNB,N-NNB-CUT,CONE,A(CUT+NNB+1,CUT+1)
$ ,LDA,WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* L11 = L11T*invD1*L11 + U01'invD*U01
+* L11 = L11**H*invD1*L11 + U01**H*invD*U01
*
DO I=1,NNB
DO J=1,I
END DO
END DO
*
-* L01 = L22T*invD2*L21
+* L01 = L22**H*invD2*L21
*
CALL ZTRMM('L',UPLO,'C','U', N-NNB-CUT, NNB,
$ CONE,A(CUT+NNB+1,CUT+NNB+1),LDA,WORK,N+NB+1)
END DO
ELSE
*
-* L11 = L11T*invD1*L11
+* L11 = L11**H*invD1*L11
*
DO I=1,NNB
DO J=1,I
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**H)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**H: P * inv(U**H)*inv(D)*inv(U) *P**H
*
I=N
DO WHILE ( I .GE. 1 )
*
* ZHFRK performs one of the Hermitian rank--k operations
*
-* C := alpha*A*conjg( A' ) + beta*C,
+* C := alpha*A*A**H + beta*C,
*
* or
*
-* C := alpha*conjg( A' )*A + beta*C,
+* 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
* On entry, TRANS specifies the operation to be performed as
* follows:
*
-* TRANS = 'N' or 'n' C := alpha*A*conjg( A' ) + beta*C.
+* TRANS = 'N' or 'n' C := alpha*A*A**H + beta*C.
*
-* TRANS = 'C' or 'c' C := alpha*conjg( A' )*A + beta*C.
+* TRANS = 'C' or 'c' C := alpha*A**H*A + beta*C.
*
* Unchanged on exit.
*
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**H).
*
CALL ZHPTRS( UPLO, N, 1, AFP, IPIV, WORK, N, INFO )
DO 110 I = 1, N
CALL ZAXPY( N-I, ALPHA, AP( II+1 ), 1, TAU( I ), 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v**H
+* A := A - v * w**H - w * v**H
*
CALL ZHPR2( UPLO, N-I, -ONE, AP( II+1 ), 1, TAU( I ), 1,
$ AP( I1I1 ) )
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**H).
*
IF ( CAPPLY ) THEN
DO I = 1, N
END DO
ELSE
*
-* Multiply by inv(X').
+* Multiply by inv(X**H).
*
DO I = 1, N
WORK( I ) = WORK( I ) / X( I )
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**H).
*
IF ( CAPPLY ) THEN
DO I = 1, N
END DO
ELSE
*
-* Multiply by inv(X').
+* Multiply by inv(X**H).
*
DO I = 1, N
WORK( I ) = WORK( I ) / X( I )
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**H).
*
IF ( CAPPLY ) THEN
DO I = 1, N
END DO
ELSE
*
-* Multiply by inv(X').
+* Multiply by inv(X**H).
*
DO I = 1, N
WORK( I ) = WORK( I ) / X( I )
*
* AF (input) 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.
+* A = U**H*U or A = L*L**H, as computed by ZPOTRF.
*
* LDAF (input) INTEGER
* The leading dimension of the array AF. LDAF >= max(1,N).
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**H).
*
IF ( CAPPLY ) THEN
DO I = 1, N
*
* AF (input) 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.
+* A = U**H*U or A = L*L**H, as computed by ZPOTRF.
*
* LDAF (input) INTEGER
* The leading dimension of the array AF. LDAF >= max(1,N).
END DO
ELSE
*
-* Multiply by inv(X').
+* Multiply by inv(X**H).
*
DO I = 1, N
WORK( I ) = WORK( I ) / X( I )
END IF
ELSE
*
-* Multiply by inv(C').
+* Multiply by inv(C**T).
*
IF ( CAPPLY ) THEN
DO I = 1, N
END DO
ELSE
*
-* Multiply by inv(X').
+* Multiply by inv(X**T).
*
DO I = 1, N
WORK( I ) = WORK( I ) / X( I )
* X (input/output) COMPLEX*16 array, dimension (N)
* On an intermediate return, X should be overwritten by
* A * X, if KASE=1,
-* A' * X, if KASE=2,
-* where A' is the conjugate transpose of A, and ZLACN2 must be
+* 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 (input/output) DOUBLE PRECISION
* KASE (input/output) 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' * X.
+* whether X should be overwritten by A * X or A**H * X.
* On the final return from ZLACN2, KASE will again be 0.
*
* ISAVE (input/output) INTEGER array, dimension (3)
* X (input/output) COMPLEX*16 array, dimension (N)
* On an intermediate return, X should be overwritten by
* A * X, if KASE=1,
-* A' * X, if KASE=2,
-* where A' is the conjugate transpose of A, and ZLACON must be
+* 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 (input/output) DOUBLE PRECISION
* KASE (input/output) 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' * X.
+* whether X should be overwritten by A * X or A**H * X.
* On the final return from ZLACON, KASE will again be 0.
*
* Further Details
*
* Choose CS1 = 1 and SN1 to satisfy the first equation, then
* scale the components of this eigenvector so that the matrix
-* of eigenvectors X satisfies X * X' = I . (No scaling is
+* of eigenvectors X satisfies X * X**T = I . (No scaling is
* done if the norm of the eigenvalue matrix is less than THRESH.)
*
SN1 = ( RT1-A ) / B
$ A( K+I-1, 1 ), LDA, ONE, A( K+1, I ), 1 )
CALL ZLACGV( I-1, A( K+I-1, 1 ), LDA )
*
-* Apply I - V * T' * V**H to this column (call it b) from the
+* Apply I - V * T**H * V**H to this column (call it b) from the
* left, using the last column of T as workspace
*
* Let V = ( V1 ) and b = ( b1 ) (first I-1 rows)
*
* where V1 is unit lower triangular
*
-* w := V1' * b1
+* w := V1**H * b1
*
CALL ZCOPY( I-1, A( K+1, I ), 1, T( 1, NB ), 1 )
CALL ZTRMV( 'Lower', 'Conjugate transpose', 'UNIT',
* [ s*x ]
* xhat = [ c ]
* is an approximate singular vector of
-* [ L 0 ]
-* Lhat = [ w' gamma ]
+* [ 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]' and sestpr**2 is an eigenpair of the system
+* Note that [s c]**H and sestpr**2 is an eigenpair of the system
*
* diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ]
* [ conjg(gamma) ]
* POLES, GIVNUM, and Z.
*
* VT (input) DOUBLE PRECISION array, dimension ( LDU, SMLSIZ+1 ).
-* On entry, VT' contains the right singular vector matrices of
+* On entry, VT**H contains the right singular vector matrices of
* all subproblems at the bottom level.
*
* K (input) INTEGER array, dimension ( N ).
*
* Since B is complex, the following call to DGEMM is performed
* in two steps (real and imaginary parts). That is for V * B
-* (in the real version of the code V' is stored in WORK).
+* (in the real version of the code V**H is stored in WORK).
*
* CALL DGEMM( 'T', 'N', N, NRHS, N, ONE, WORK, N, B, LDB, ZERO,
* $ WORK( NWORK ), N )
ELSE
* A is xpose & A is k by n
IF( ILU.EQ.0 ) THEN
-* A' is upper
+* A**H is upper
DO J = 1, K - 2
CALL ZLASSQ( J, A( 0+( K+J )*LDA ), 1, SCALE, S )
* U at A(0,k)
L = L + LDA + 1
END DO
ELSE
-* A' is lower
+* A**H is lower
DO J = 1, K - 1
CALL ZLASSQ( J, A( 0+J*LDA ), 1, SCALE, S )
* U at A(0,0)
ELSE
* A is xpose
IF( ILU.EQ.0 ) THEN
-* A' is upper
+* A**H is upper
DO J = 1, K - 1
CALL ZLASSQ( J, A( 0+( K+1+J )*LDA ), 1, SCALE, S )
* U at A(0,k+1)
END IF
END IF
ELSE
-* A' is lower
+* A**H is lower
DO J = 1, K - 1
CALL ZLASSQ( J, A( 0+( J+1 )*LDA ), 1, SCALE, S )
* U at A(0,1)
CALL ZLACPY( 'ALL', KNZ, JLEN, H( INCOL+1+J2, JCOL ),
$ LDH, WH( KZS+1, 1 ), LDWH )
*
-* ==== Multiply by U21' ====
+* ==== Multiply by U21**H ====
*
CALL ZLASET( 'ALL', KZS, JLEN, ZERO, ZERO, WH, LDWH )
CALL ZTRMM( 'L', 'U', 'C', 'N', KNZ, JLEN, ONE,
$ U( J2+1, 1+KZS ), LDU, WH( KZS+1, 1 ),
$ LDWH )
*
-* ==== Multiply top of H by U11' ====
+* ==== Multiply top of H by U11**H ====
*
CALL ZGEMM( 'C', 'N', I2, JLEN, J2, ONE, U, LDU,
$ H( INCOL+1, JCOL ), LDH, ONE, WH, LDWH )
CALL ZLACPY( 'ALL', J2, JLEN, H( INCOL+1, JCOL ), LDH,
$ WH( I2+1, 1 ), LDWH )
*
-* ==== Multiply by U21' ====
+* ==== Multiply by U21**H ====
*
CALL ZTRMM( 'L', 'L', 'C', 'N', J2, JLEN, ONE,
$ U( 1, I2+1 ), LDU, WH( I2+1, 1 ), LDWH )
LASTV = MAX( K, ILAZLR( M, K, V, LDV ) )
LASTC = ILAZLC( LASTV, N, C, LDC )
*
-* W := C' * V = (C1**H * V1 + C2**H * V2) (stored in WORK)
+* W := C**H * V = (C1**H * V1 + C2**H * V2) (stored in WORK)
*
* W := C2**H
*
* 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 = 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' * T * V
+* H = I - V**H * T * V
*
* Currently, only STOREV = 'R' and DIRECT = 'B' are supported.
*
END IF
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form A * P'
+* Form A * P**T
*
IF( LSAME( PIVOT, 'V' ) ) THEN
IF( LSAME( DIRECT, 'F' ) ) THEN
* 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' denotes the transpose of A, x and b
+* 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
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**H).
*
CALL ZPBTRS( UPLO, N, KD, 1, AFB, LDAFB, WORK, N, INFO )
DO 110 I = 1, N
*
* on entry: on exit:
*
-* * * a13 a24 a35 a46 a57 * * s13 s24 s53' s64' s75'
-* * a12 a23 a34 a45 a56 a67 * s12 s23 s34 s54' s65' s76'
-* a11 a22 a33 a44 a55 a66 a77 s11 s22 s33 s44 s55 s66 s77
+* * * a13 a24 a35 a46 a57 * * s13 s24 s53**H s64**H s75**H
+* * a12 a23 a34 a45 a56 a67 * s12 s23 s34 s54**H s65**H s76**H
+* a11 a22 a33 a44 a55 a66 a77 s11 s22 s33 s44 s55 s66 s77
*
* If UPLO = 'L', the array AB holds:
*
* on entry: on exit:
*
-* a11 a22 a33 a44 a55 a66 a77 s11 s22 s33 s44 s55 s66 s77
-* a21 a32 a43 a54 a65 a76 * s12' s23' s34' s54 s65 s76 *
-* a31 a42 a53 a64 a64 * * s13' s24' s53 s64 s75 * *
+* a11 a22 a33 a44 a55 a66 a77 s11 s22 s33 s44 s55 s66 s77
+* a21 a32 a43 a54 a65 a76 * s12**H s23**H s34**H s54 s65 s76 *
+* a31 a42 a53 a64 a64 * * s13**H s24**H s53 s64 s75 * *
*
-* Array elements marked * are not used by the routine; s12' denotes
+* Array elements marked * are not used by the routine; s12**H denotes
* conjg(s12); the diagonal elements of S are real.
+
*
* =====================================================================
*
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**H).
*
CALL ZPOTRS( UPLO, N, 1, AF, LDAF, WORK, N, INFO )
DO 110 I = 1, N
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**H).
*
CALL ZPPTRS( UPLO, N, 1, AFP, WORK, N, INFO )
DO 110 I = 1, N
* A = U**H * U , if UPLO = 'U', or
* A = L * L**H, if UPLO = 'L',
* where U is an upper triangular matrix, L is a lower triangular
-* matrix, and ' indicates conjugate transpose.
+* matrix, and **H indicates conjugate transpose.
*
* 3. If the leading i-by-i principal minor is not positive definite,
* then the routine returns with INFO = i. Otherwise, the factored
* pivoting of a complex Hermitian positive semidefinite matrix A.
*
* The factorization has the form
-* P' * A * P = U' * U , if UPLO = 'U',
-* P' * A * P = L * L', if UPLO = 'L',
+* 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.
*
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization P' * A * P = U' * U
+* Compute the Cholesky factorization P**T * A * P = U**H* U
*
DO 150 J = 1, N
*
*
ELSE
*
-* Compute the Cholesky factorization P' * A * P = L * L'
+* Compute the Cholesky factorization P**T * A * P = L * L**H
*
DO 180 J = 1, N
*
* pivoting of a complex Hermitian positive semidefinite matrix A.
*
* The factorization has the form
-* P' * A * P = U' * U , if UPLO = 'U',
-* P' * A * P = L * L', if UPLO = 'L',
+* 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.
*
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization P' * A * P = U' * U
+* Compute the Cholesky factorization P**T * A * P = U**H * U
*
DO 160 K = 1, N, NB
*
*
ELSE
*
-* Compute the Cholesky factorization P' * A * P = L * L'
+* Compute the Cholesky factorization P**T * A * P = L * L**H
*
DO 210 K = 1, N, NB
*
* m(i,j) = abs(A(i,j)), i = j,
* m(i,j) = -abs(A(i,j)), i .ne. j,
*
-* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**H.
+* and e = [ 1, 1, ..., 1 ]**T. Note M(A) = M(L)*D*M(L)**H.
*
* Solve M(L) * x = e.
*
* m(i,j) = abs(A(i,j)), i = j,
* m(i,j) = -abs(A(i,j)), i .ne. j,
*
-* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**H.
+* and e = [ 1, 1, ..., 1 ]**T. Note M(A) = M(L)*D*M(L)**H.
*
* Solve M(L) * x = e.
*
*
* ZSPR performs the symmetric rank 1 operation
*
-* A := alpha*x*conjg( x' ) + A,
+* 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.
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL ZSPTRS( UPLO, N, 1, AFP, IPIV, WORK, N, INFO )
DO 110 I = 1, N
*
* ZSYR performs the symmetric rank 1 operation
*
-* A := alpha*x*( x' ) + A,
+* 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.
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(A').
+* Multiply by diag(W)*inv(A**T).
*
CALL ZSYTRS( UPLO, N, 1, AF, LDAF, IPIV, WORK, N, INFO )
DO 110 I = 1, N
IF( UPPER ) THEN
*
-* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P**T.
*
CALL ZTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* U11T*invD1*U11->U11
+* U11**T*invD1*U11->U11
*
CALL ZTRMM('L','U','T','U',NNB, NNB,
$ ONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
END DO
END DO
*
-* U01'invD*U01->A(CUT+I,CUT+J)
+* U01**T*invD*U01->A(CUT+I,CUT+J)
*
CALL ZGEMM('T','N',NNB,NNB,CUT,ONE,A(1,CUT+1),LDA,
$ WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* U11 = U11T*invD1*U11 + U01'invD*U01
+* U11 = U11**T*invD1*U11 + U01**T*invD*U01
*
DO I=1,NNB
DO J=I,NNB
END DO
END DO
*
-* U01 = U00T*invD0*U01
+* U01 = U00**T*invD0*U01
*
CALL ZTRMM('L',UPLO,'T','U',CUT, NNB,
$ ONE,A,LDA,WORK,N+NB+1)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**T: P * inv(U**T)*inv(D)*inv(U) *P**T
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P**T.
*
CALL ZTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* L11T*invD1*L11->L11
+* L11**T*invD1*L11->L11
*
CALL ZTRMM('L',UPLO,'T','U',NNB, NNB,
$ ONE,A(CUT+1,CUT+1),LDA,WORK(U11+1,1),N+NB+1)
IF ( (CUT+NNB) .LT. N ) THEN
*
-* L21T*invD2*L21->A(CUT+I,CUT+J)
+* L21**T*invD2*L21->A(CUT+I,CUT+J)
*
CALL ZGEMM('T','N',NNB,NNB,N-NNB-CUT,ONE,A(CUT+NNB+1,CUT+1)
$ ,LDA,WORK,N+NB+1, ZERO, WORK(U11+1,1), N+NB+1)
*
-* L11 = L11T*invD1*L11 + U01'invD*U01
+* L11 = L11**T*invD1*L11 + U01**T*invD*U01
*
DO I=1,NNB
DO J=1,I
END DO
END DO
*
-* U01 = L22T*invD2*L21
+* U01 = L22**T*invD2*L21
*
CALL ZTRMM('L',UPLO,'T','U', N-NNB-CUT, NNB,
$ ONE,A(CUT+NNB+1,CUT+NNB+1),LDA,WORK,N+NB+1)
END DO
ELSE
*
-* L11 = L11T*invD1*L11
+* L11 = L11**T*invD1*L11
*
DO I=1,NNB
DO J=1,I
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P**T: P * inv(U**T)*inv(D)*inv(U) *P**T
*
I=N
DO WHILE ( I .GE. 1 )
RCOND = ZERO
SMLNUM = DLAMCH( 'Safe minimum' )*DBLE( MAX( N, 1 ) )
*
-* Compute the 1-norm of the triangular matrix A or A'.
+* Compute the 1-norm of the triangular matrix A or A**H.
*
ANORM = ZLANTB( NORM, UPLO, DIAG, N, KD, AB, LDAB, RWORK )
*
$ AB, LDAB, WORK, SCALE, RWORK, INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**H).
*
CALL ZLATBS( UPLO, 'Conjugate transpose', DIAG, NORMIN,
$ N, KD, AB, LDAB, WORK, SCALE, RWORK, INFO )
* 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 ) = conjg( A' ).
+* op( A ) = A or op( A ) = A**H.
*
* A is in Rectangular Full Packed (RFP) Format.
*
*
* ZTGEXC reorders the generalized Schur decomposition of a complex
* matrix pair (A,B), using an unitary equivalence transformation
-* (A, B) := Q * (A, B) * Z', so that the diagonal block of (A, B) with
+* (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
* where sigma-min(Zu) is the smallest singular value of the
* (2*n1*n2)-by-(2*n1*n2) matrix
*
-* Zu = [ kron(In2, A11) -kron(A22', In1) ]
-* [ kron(In2, B11) -kron(B22', In1) ].
+* Zu = [ kron(In2, A11) -kron(A22**H, In1) ]
+* [ kron(In2, B11) -kron(B22**H, In1) ].
*
-* Here, Inx is the identity matrix of size nx and A22' is the
-* transpose of A22. kron(X, Y) is the Kronecker product between
+* Here, Inx is the identity matrix of size nx and A22**H is the
+* conjugate transpose of A22. kron(X, Y) is the Kronecker product between
* the matrices X and Y.
*
* When DIF(2) is small, small changes in (A, B) can cause large changes
*
* ZTGSY2 solves the generalized Sylvester equation
*
-* A * R - L * B = scale * C (1)
+* 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,
* In matrix notation solving equation (1) corresponds to solve
* Zx = scale * b, where Z is defined as
*
-* Z = [ kron(In, A) -kron(B', Im) ] (2)
-* [ kron(In, D) -kron(E', Im) ],
+* 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' is the transpose of X.
+* 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'y = scale*b
+* 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' * R + D' * L = scale * C (3)
-* R * B' + L * E' = scale * -F
+* 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.
DO 80 I = 1, M
DO 70 J = N, 1, -1
*
-* Build 2 by 2 system Z'
+* Build 2 by 2 system Z**H
*
Z( 1, 1 ) = DCONJG( A( I, I ) )
Z( 2, 1 ) = -DCONJG( B( J, J ) )
RHS( 1 ) = C( I, J )
RHS( 2 ) = F( I, J )
*
-* Solve Z' * x = RHS
+* Solve Z**H * x = RHS
*
CALL ZGETC2( LDZ, Z, LDZ, IPIV, JPIV, IERR )
IF( IERR.GT.0 )
* In matrix notation (1) is equivalent to solve Zx = scale*b, where Z
* is defined as
*
-* Z = [ kron(In, A) -kron(B', Im) ] (2)
-* [ kron(In, D) -kron(E', Im) ],
+* 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' is the conjugate
+* 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.
*
$ WORK, SCALE, RWORK, INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**H).
*
CALL ZLATPS( UPLO, 'Conjugate transpose', DIAG, NORMIN,
$ N, AP, WORK, SCALE, RWORK, INFO )
$ LDA, WORK, SCALE, RWORK, INFO )
ELSE
*
-* Multiply by inv(A').
+* Multiply by inv(A**H).
*
CALL ZLATRS( UPLO, 'Conjugate transpose', DIAG, NORMIN,
$ N, A, LDA, WORK, SCALE, RWORK, INFO )
* 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
+* 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
+* 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'.
+* case N even and TRANSR = 'N'.
*
* RFP A RFP A
*
* -- -- --
* 02 12 22 50 51 52
*
-* Now let TRANSR = `C'. RFP A in both UPLO cases is just the conjugate-
+* Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
* transpose of RFP A above. One therefore gets:
*
*
* 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
+* 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
+* 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'.
+* case N odd and TRANSR = 'N'.
*
* RFP A RFP A
*
* -- --
* 01 11 44 40 41 42
*
-* Now let TRANSR = `C'. RFP A in both UPLO cases is just the conjugate-
+* Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
* transpose of RFP A above. One therefore gets:
*
*
END IF
ELSE
*
-* Form P', determined by a call to ZGEBRD to reduce a k-by-n
+* Form P**H, determined by a call to ZGEBRD to reduce a k-by-n
* matrix
*
IF( K.LT.N ) THEN
* If k >= n, assume m = n
*
* Shift the vectors which define the elementary reflectors one
-* row downward, and set the first row and column of P' to
+* row downward, and set the first row and column of P**H to
* those of the unit matrix
*
A( 1, 1 ) = ONE
60 CONTINUE
IF( N.GT.1 ) THEN
*
-* Form P'(2:n,2:n)
+* Form P**H(2:n,2:n)
*
CALL ZUNGLQ( N-1, N-1, N-1, A( 2, 2 ), LDA, TAU, WORK,
$ LWORK, IINFO )
projects / platform / upstream / lapack.git / commitdiff