* =======
*
* CGBBRD reduces a complex general m-by-n band matrix A to real upper
-* bidiagonal form B by a unitary transformation: Q' * A * P = B.
+* bidiagonal form B by a unitary transformation: Q**H * A * P = B.
*
-* The routine computes B, and optionally forms Q or P', or computes
-* Q'*C for a given matrix C.
+* The routine computes B, and optionally forms Q or P**H, or computes
+* Q**H*C for a given matrix C.
*
* Arguments
* =========
*
* VECT (input) CHARACTER*1
-* Specifies whether or not the matrices Q and P' are to be
+* Specifies whether or not the matrices Q and P**H are to be
* formed.
-* = 'N': do not form Q or P';
+* = 'N': do not form Q or P**H;
* = 'Q': form Q only;
-* = 'P': form P' only;
+* = 'P': form P**H only;
* = 'B': form both.
*
* M (input) INTEGER
*
* C (input/output) COMPLEX array, dimension (LDC,NCC)
* On entry, an m-by-ncc matrix C.
-* On exit, C is overwritten by Q'*C.
+* On exit, C is overwritten by Q**H*C.
* C is not referenced if NCC = 0.
*
* LDC (input) INTEGER
RETURN
END IF
*
-* Initialize Q and P' to the unit matrix, if needed
+* Initialize Q and P**H to the unit matrix, if needed
*
IF( WANTQ )
$ CALL CLASET( 'Full', M, M, CZERO, CONE, Q, LDQ )
*
IF( WANTPT ) THEN
*
-* accumulate product of plane rotations in P'
+* accumulate product of plane rotations in P**H
*
DO 60 J = J1, J2, KB1
CALL CROT( N, PT( J+KUN-1, 1 ), LDPT,
$ KL+KU, AB, LDAB, WORK, SCALE, RWORK, INFO )
ELSE
*
-* Multiply by inv(U').
+* Multiply by inv(U**H).
*
CALL CLATBS( 'Upper', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, KL+KU, AB, LDAB, WORK, SCALE, RWORK,
$ INFO )
*
-* Multiply by inv(L').
+* Multiply by inv(L**H).
*
IF( LNOTI ) THEN
DO 30 J = N - 1, 1, -1
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**H and G(i) = I - taup * u * u**H
*
* where tauq and taup are complex scalars, and v and u are complex
* vectors; v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**H and G(i) = I - taup * u * u**H
*
* where tauq and taup are complex scalars, v and u are complex vectors;
* v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in A(i+2:m,i);
D( I ) = ALPHA
A( I, I ) = ONE
*
-* Apply H(i)' to A(i:m,i+1:n) from the left
+* Apply H(i)**H to A(i:m,i+1:n) from the left
*
IF( I.LT.N )
$ CALL CLARF( 'Left', M-I+1, N-I, A( I, I ), 1,
E( I ) = ALPHA
A( I+1, I ) = ONE
*
-* Apply H(i)' to A(i+1:m,i+1:n) from the left
+* Apply H(i)**H to A(i+1:m,i+1:n) from the left
*
CALL CLARF( 'Left', M-I, N-I, A( I+1, I ), 1,
$ CONJG( TAUQ( I ) ), A( I+1, I+1 ), LDA,
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**H and G(i) = I - taup * u * u**H
*
* where tauq and taup are complex scalars, and v and u are complex
* vectors; v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**H and G(i) = I - taup * u * u**H
*
* where tauq and taup are complex scalars, and v and u are complex
* vectors; v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in
$ WORK( LDWRKX*NB+1 ), LDWRKY )
*
* Update the trailing submatrix A(i+ib:m,i+ib:n), using
-* an update of the form A := A - V*Y' - X*U'
+* an update of the form A := A - V*Y**H - X*U**H
*
CALL CGEMM( 'No transpose', 'Conjugate transpose', M-I-NB+1,
$ N-I-NB+1, NB, -ONE, A( I+NB, I ), LDA,
$ A, LDA, WORK, SU, RWORK( N+1 ), INFO )
ELSE
*
-* Multiply by inv(U').
+* Multiply by inv(U**H).
*
CALL CLATRS( 'Upper', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, A, LDA, WORK, SU, RWORK( N+1 ),
$ INFO )
*
-* Multiply by inv(L').
+* Multiply by inv(L**H).
*
CALL CLATRS( 'Lower', 'Conjugate transpose', 'Unit', NORMIN,
$ N, A, LDA, WORK, SL, RWORK, INFO )
* =======
*
* CGEHD2 reduces a complex general matrix A to upper Hessenberg form H
-* by a unitary similarity transformation: Q' * A * Q = H .
+* by a unitary similarity transformation: Q**H * A * Q = H .
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on
CALL CLARF( 'Right', IHI, IHI-I, A( I+1, I ), 1, TAU( I ),
$ A( 1, I+1 ), LDA, WORK )
*
-* Apply H(i)' to A(i+1:ihi,i+1:n) from the left
+* Apply H(i)**H to A(i+1:ihi,i+1:n) from the left
*
CALL CLARF( 'Left', IHI-I, N-I, A( I+1, I ), 1,
$ CONJG( TAU( I ) ), A( I+1, I+1 ), LDA, WORK )
* =======
*
* CGEHRD reduces a complex general matrix A to upper Hessenberg form H by
-* an unitary similarity transformation: Q' * A * Q = H .
+* an unitary similarity transformation: Q**H * A * Q = H .
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on
IB = MIN( NB, IHI-I )
*
* Reduce columns i:i+ib-1 to Hessenberg form, returning the
-* matrices V and T of the block reflector H = I - V*T*V'
+* matrices V and T of the block reflector H = I - V*T*V**H
* which performs the reduction, and also the matrix Y = A*V*T
*
CALL CLAHR2( IHI, I, IB, A( 1, I ), LDA, TAU( I ), T, LDT,
$ WORK, LDWORK )
*
* Apply the block reflector H to A(1:ihi,i+ib:ihi) from the
-* right, computing A := A - Y * V'. V(i+ib,ib-1) must be set
+* right, computing A := A - Y * V**H. V(i+ib,ib-1) must be set
* to 1
*
EI = A( I+IB, I+IB-1 )
*
* The matrix Q is represented as a product of elementary reflectors
*
-* Q = H(k)' . . . H(2)' H(1)', where k = min(m,n).
+* Q = H(k)**H . . . H(2)**H H(1)**H, where k = min(m,n).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; conjg(v(i+1:n)) is stored on exit in
*
* The matrix Q is represented as a product of elementary reflectors
*
-* Q = H(k)' . . . H(2)' H(1)', where k = min(m,n).
+* Q = H(k)**H . . . H(2)**H H(1)**H, where k = min(m,n).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; conjg(v(i+1:n)) is stored on exit in
*
* Least-Squares Problem min || A * X - B ||
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**H * B(1:M,1:NRHS)
*
CALL CUNMQR( 'Left', 'Conjugate transpose', M, NRHS, N, A,
$ LDA, WORK( 1 ), B, LDB, WORK( MN+1 ), LWORK-MN,
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Q(1:N,:)' * B(1:M,1:NRHS)
+* B(1:N,1:NRHS) := Q(1:N,:)**H * B(1:M,1:NRHS)
*
CALL CUNMLQ( 'Left', 'Conjugate transpose', N, NRHS, M, A,
$ LDA, WORK( 1 ), B, LDB, WORK( MN+1 ), LWORK-MN,
* 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.
*
* Arguments
*
* Details of Householder rotations stored in WORK(MN+1:2*MN)
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**H * B(1:M,1:NRHS)
*
CALL CUNM2R( 'Left', 'Conjugate transpose', M, NRHS, MN, A, LDA,
$ WORK( 1 ), B, LDB, WORK( 2*MN+1 ), INFO )
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Y' * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := Y**H * B(1:N,1:NRHS)
*
IF( RANK.LT.N ) THEN
DO 50 I = 1, RANK
* complex workspace: 2*MN.
* Details of Householder rotations stored in WORK(MN+1:2*MN)
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**H * B(1:M,1:NRHS)
*
CALL CUNMQR( 'Left', 'Conjugate transpose', M, NRHS, MN, A, LDA,
$ WORK( 1 ), B, LDB, WORK( 2*MN+1 ), LWORK-2*MN, INFO )
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Y' * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := Y**H * B(1:N,1:NRHS)
*
IF( RANK.LT.N ) THEN
CALL CUNMRZ( 'Left', 'Conjugate transpose', N, NRHS, RANK,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in
ALPHA = A( M-K+I, N-K+I )
CALL CLARFG( M-K+I, ALPHA, A( 1, N-K+I ), 1, TAU( I ) )
*
-* Apply H(i)' to A(1:m-k+i,1:n-k+i-1) from the left
+* Apply H(i)**H to A(1:m-k+i,1:n-k+i-1) from the left
*
A( M-K+I, N-K+I ) = ONE
CALL CLARF( 'Left', M-K+I, N-K+I-1, A( 1, N-K+I ), 1,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in
CALL CLARFT( 'Backward', 'Columnwise', M-K+I+IB-1, IB,
$ A( 1, N-K+I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(1:m-k+i+ib-1,1:n-k+i-1) from the left
+* Apply H**H to A(1:m-k+i+ib-1,1:n-k+i-1) from the left
*
CALL CLARFB( 'Left', 'Conjugate transpose', 'Backward',
$ 'Columnwise', M-K+I+IB-1, N-K+I-1, IB,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a real/complex scalar, and v is a real/complex vector
* with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in
*
* Each H(i) has the form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
$ TAU( I ) )
IF( I.LT.N ) THEN
*
-* Apply H(i)' to A(i:m,i+1:n) from the left
+* Apply H(i)**H to A(i:m,i+1:n) from the left
*
ALPHA = A( I, I )
A( I, I ) = ONE
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
$ TAU( I ) )
IF( I.LT.N ) THEN
*
-* Apply H(i)' to A(i:m,i+1:n) from the left
+* Apply H(i)**H to A(i:m,i+1:n) from the left
*
ALPHA = A( I, I )
A( I, I ) = ONE
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
CALL CLARFT( 'Forward', 'Columnwise', M-I+1, IB,
$ A( I, I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i:m,i+ib:n) from the left
+* Apply H**H to A(i:m,i+ib:n) from the left
*
CALL CLARFB( 'Left', 'Conjugate transpose', 'Forward',
$ 'Columnwise', M-I+1, N-I-IB+1, IB,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
CALL CLARFT( 'Forward', 'Columnwise', M-I+1, IB,
$ A( I, I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i:m,i+ib:n) from the left
+* Apply H**H to A(i:m,i+ib:n) from the left
*
CALL CLARFB( 'Left', 'Conjugate transpose', 'Forward',
$ 'Columnwise', M-I+1, N-I-IB+1, IB,
*
* The matrix Q is represented as a product of elementary reflectors
*
-* Q = H(1)' H(2)' . . . H(k)', where k = min(m,n).
+* Q = H(1)**H H(2)**H . . . H(k)**H, where k = min(m,n).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; conjg(v(1:n-k+i-1)) is stored on
*
* The matrix Q is represented as a product of elementary reflectors
*
-* Q = H(1)' H(2)' . . . H(k)', where k = min(m,n).
+* Q = H(1)**H H(2)**H . . . H(k)**H, where k = min(m,n).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; conjg(v(1:n-k+i-1)) is stored on
*
* Solve A**T * X = B or A**H * X = B.
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**T *X = B or U**H *X = B, overwriting B with X.
*
CALL CTRSM( 'Left', 'Upper', TRANS, 'Non-unit', N, NRHS, ONE,
$ A, LDA, B, LDB )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**T *X = B, or L**H *X = B overwriting B with X.
*
CALL CTRSM( 'Left', 'Lower', TRANS, 'Unit', N, NRHS, ONE, A,
$ LDA, B, LDB )
*
* Compute the GQR factorization of matrices A and B:
*
-* Q'*A = ( R11 ) M, Q'*B*Z' = ( T11 T12 ) M
-* ( 0 ) N-M ( 0 T22 ) N-M
-* M M+P-N N-M
+* Q**H*A = ( R11 ) M, Q**H*B*Z**H = ( T11 T12 ) M
+* ( 0 ) N-M ( 0 T22 ) N-M
+* M M+P-N N-M
*
* where R11 and T22 are upper triangular, and Q and Z are
* unitary.
$ WORK( M+NP+1 ), LWORK-M-NP, INFO )
LOPT = WORK( M+NP+1 )
*
-* Update left-hand-side vector d = Q'*d = ( d1 ) M
-* ( d2 ) N-M
+* Update left-hand-side vector d = Q**H*d = ( d1 ) M
+* ( d2 ) N-M
*
CALL CUNMQR( 'Left', 'Conjugate transpose', N, 1, M, A, LDA, WORK,
$ D, MAX( 1, N ), WORK( M+NP+1 ), LWORK-M-NP, INFO )
CALL CCOPY( M, D, 1, X, 1 )
END IF
*
-* Backward transformation y = Z'*y
+* Backward transformation y = Z**H *y
*
CALL CUNMRQ( 'Left', 'Conjugate transpose', P, 1, NP,
$ B( MAX( 1, N-P+1 ), 1 ), LDB, WORK( M+1 ), Y,
*
* Compute the GRQ factorization of matrices B and A:
*
-* B*Q' = ( 0 T12 ) P Z'*A*Q' = ( R11 R12 ) N-P
-* N-P P ( 0 R22 ) M+P-N
-* N-P P
+* B*Q**H = ( 0 T12 ) P Z**H*A*Q**H = ( R11 R12 ) N-P
+* N-P P ( 0 R22 ) M+P-N
+* N-P P
*
* where T12 and R11 are upper triangular, and Q and Z are
* unitary.
$ WORK( P+MN+1 ), LWORK-P-MN, INFO )
LOPT = WORK( P+MN+1 )
*
-* Update c = Z'*c = ( c1 ) N-P
+* Update c = Z**H *c = ( c1 ) N-P
* ( c2 ) M+P-N
*
CALL CUNMQR( 'Left', 'Conjugate Transpose', M, 1, MN, A, LDA,
CALL CAXPY( NR, -CONE, D, 1, C( N-P+1 ), 1 )
END IF
*
-* Backward transformation x = Q'*x
+* Backward transformation x = Q**H*x
*
CALL CUNMRQ( 'Left', 'Conjugate Transpose', N, 1, P, B, LDB,
$ WORK( 1 ), X, N, WORK( P+MN+1 ), LWORK-P-MN, INFO )
* In particular, if B is square and nonsingular, the GQR factorization
* of A and B implicitly gives the QR factorization of inv(B)*A:
*
-* inv(B)*A = Z'*(inv(T)*R)
+* inv(B)*A = Z**H * (inv(T)*R)
*
* where inv(B) denotes the inverse of the matrix B, and Z' denotes the
* conjugate transpose of matrix Z.
*
* Each H(i) has the form
*
-* H(i) = I - taua * v * v'
+* H(i) = I - taua * v * v**H
*
* where taua is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i+1:n,i),
*
* Each H(i) has the form
*
-* H(i) = I - taub * v * v'
+* H(i) = I - taub * v * v**H
*
* where taub is a complex scalar, and v is a complex vector with
* v(p-k+i+1:p) = 0 and v(p-k+i) = 1; v(1:p-k+i-1) is stored on exit in
CALL CGEQRF( N, M, A, LDA, TAUA, WORK, LWORK, INFO )
LOPT = WORK( 1 )
*
-* Update B := Q'*B.
+* Update B := Q**H*B.
*
CALL CUNMQR( 'Left', 'Conjugate Transpose', N, P, MIN( N, M ), A,
$ LDA, TAUA, B, LDB, WORK, LWORK, INFO )
* In particular, if B is square and nonsingular, the GRQ factorization
* of A and B implicitly gives the RQ factorization of A*inv(B):
*
-* A*inv(B) = (R*inv(T))*Z'
+* A*inv(B) = (R*inv(T))*Z**H
*
-* where inv(B) denotes the inverse of the matrix B, and Z' denotes the
+* where inv(B) denotes the inverse of the matrix B, and Z**H denotes the
* conjugate transpose of the matrix Z.
*
* Arguments
*
* Each H(i) has the form
*
-* H(i) = I - taua * v * v'
+* H(i) = I - taua * v * v**H
*
* where taua is a complex scalar, and v is a complex vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - taub * v * v'
+* H(i) = I - taub * v * v**H
*
* where taub is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:p) is stored on exit in B(i+1:p,i),
CALL CGERQF( M, N, A, LDA, TAUA, WORK, LWORK, INFO )
LOPT = WORK( 1 )
*
-* Update B := B*Q'
+* Update B := B*Q**H
*
CALL CUNMRQ( 'Right', 'Conjugate Transpose', P, N, MIN( M, N ),
$ A( MAX( 1, M-N+1 ), 1 ), LDA, TAUA, B, LDB, WORK,
* CGGSVD computes the generalized singular value decomposition (GSVD)
* of an M-by-N complex matrix A and P-by-N complex matrix B:
*
-* U'*A*Q = D1*( 0 R ), V'*B*Q = D2*( 0 R )
+* U**H*A*Q = D1*( 0 R ), V**H*B*Q = D2*( 0 R )
*
-* where U, V and Q are unitary matrices, and Z' means the conjugate
-* transpose of Z. Let K+L = the effective numerical rank of the
-* matrix (A',B')', then R is a (K+L)-by-(K+L) nonsingular upper
+* where U, V and Q are unitary matrices.
+* Let K+L = the effective numerical rank of the
+* matrix (A**H,B**H)**H, then R is a (K+L)-by-(K+L) nonsingular upper
* triangular matrix, D1 and D2 are M-by-(K+L) and P-by-(K+L) "diagonal"
* matrices and of the following structures, respectively:
*
* N-K-L K L
* ( 0 R ) = K ( 0 R11 R12 )
* L ( 0 0 R22 )
+*
* where
*
* C = diag( ALPHA(K+1), ... , ALPHA(K+L) ),
*
* In particular, if B is an N-by-N nonsingular matrix, then the GSVD of
* A and B implicitly gives the SVD of A*inv(B):
-* A*inv(B) = U*(D1*inv(D2))*V'.
-* If ( A',B')' has orthnormal columns, then the GSVD of A and B is also
+* A*inv(B) = U*(D1*inv(D2))*V**H.
+* If ( A**H,B**H)**H has orthnormal columns, then the GSVD of A and B is also
* equal to the CS decomposition of A and B. Furthermore, the GSVD can
* be used to derive the solution of the eigenvalue problem:
-* A'*A x = lambda* B'*B x.
+* A**H*A x = lambda* B**H*B x.
* In some literature, the GSVD of A and B is presented in the form
-* U'*A*X = ( 0 D1 ), V'*B*X = ( 0 D2 )
+* U**H*A*X = ( 0 D1 ), V**H*B*X = ( 0 D2 )
* where U and V are orthogonal and X is nonsingular, and D1 and D2 are
* ``diagonal''. The former GSVD form can be converted to the latter
* form by taking the nonsingular matrix X as
* L (output) INTEGER
* On exit, K and L specify the dimension of the subblocks
* described in Purpose.
-* K + L = effective numerical rank of (A',B')'.
+* K + L = effective numerical rank of (A**H,B**H)**H.
*
* A (input/output) COMPLEX 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')'. Generally, they are set to
+* rank of (A',B')**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
*
* CGGSVP computes unitary matrices U, V and Q such that
*
-* N-K-L K L
-* U'*A*Q = K ( 0 A12 A13 ) if M-K-L >= 0;
-* L ( 0 0 A23 )
-* M-K-L ( 0 0 0 )
+* N-K-L K L
+* U**H*A*Q = K ( 0 A12 A13 ) if M-K-L >= 0;
+* L ( 0 0 A23 )
+* M-K-L ( 0 0 0 )
*
* N-K-L K L
* = K ( 0 A12 A13 ) if M-K-L < 0;
* M-K ( 0 0 A23 )
*
-* N-K-L K L
-* V'*B*Q = L ( 0 0 B13 )
-* P-L ( 0 0 0 )
+* N-K-L K L
+* V**H*B*Q = L ( 0 0 B13 )
+* P-L ( 0 0 0 )
*
* where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular
* upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,
* otherwise A23 is (M-K)-by-L upper trapezoidal. K+L = the effective
-* numerical rank of the (M+P)-by-N matrix (A',B')'. Z' denotes the
-* conjugate transpose of Z.
+* numerical rank of the (M+P)-by-N matrix (A**H,B**H)**H.
*
* This decomposition is the preprocessing step for computing the
* Generalized Singular Value Decomposition (GSVD), see subroutine
* L (output) INTEGER
* On exit, K and L specify the dimension of the subblocks
* described in Purpose section.
-* K + L = effective numerical rank of (A',B')'.
+* K + L = effective numerical rank of (A**H,B**H)**H.
*
* U (output) COMPLEX array, dimension (LDU,M)
* If JOBU = 'U', U contains the unitary matrix U.
*
CALL CGERQ2( L, N, B, LDB, TAU, WORK, INFO )
*
-* Update A := A*Z'
+* Update A := A*Z**H
*
CALL CUNMR2( 'Right', 'Conjugate transpose', M, N, L, B, LDB,
$ TAU, A, LDA, WORK, INFO )
IF( WANTQ ) THEN
*
-* Update Q := Q*Z'
+* Update Q := Q*Z**H
*
CALL CUNMR2( 'Right', 'Conjugate transpose', N, N, L, B,
$ LDB, TAU, Q, LDQ, WORK, INFO )
*
* then the following does the complete QR decomposition of A11:
*
-* A11 = U*( 0 T12 )*P1'
+* A11 = U*( 0 T12 )*P1**H
* ( 0 0 )
*
DO 70 I = 1, N - L
$ K = K + 1
80 CONTINUE
*
-* Update A12 := U'*A12, where A12 = A( 1:M, N-L+1:N )
+* Update A12 := U**H*A12, where A12 = A( 1:M, N-L+1:N )
*
CALL CUNM2R( 'Left', 'Conjugate transpose', M, L, MIN( M, N-L ),
$ A, LDA, TAU, A( 1, N-L+1 ), LDA, WORK, INFO )
*
IF( WANTQ ) THEN
*
-* Update Q( 1:N,1:N-L ) = Q( 1:N,1:N-L )*Z1'
+* Update Q( 1:N,1:N-L ) = Q( 1:N,1:N-L )*Z1**H
*
CALL CUNMR2( 'Right', 'Conjugate transpose', N, N-L, K, A,
$ LDA, TAU, Q, LDQ, WORK, INFO )
$ WORK, N, INFO )
ELSE
*
-* Multiply by inv(L')*inv(U').
+* Multiply by inv(L**H)*inv(U**H).
*
CALL CGTTRS( 'Conjugate transpose', N, 1, DL, D, DU, DU2,
$ IPIV, WORK, N, INFO )
* where A is an N-by-N tridiagonal matrix, by Gaussian elimination with
* partial pivoting.
*
-* Note that the equation A'*X = B may be solved by interchanging the
+* Note that the equation A**H *X = B may be solved by interchanging the
* order of the arguments DU and DL.
*
* Arguments
CALL CLACN2( N, WORK( N+1 ), WORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**H) or inv(U*D*U**H).
*
CALL CHETRS( UPLO, N, 1, A, LDA, IPIV, WORK, N, INFO )
GO TO 30
* eigenproblem to standard form.
*
* If ITYPE = 1, the problem is A*x = lambda*B*x,
-* and A is overwritten by inv(U')*A*inv(U) or inv(L)*A*inv(L')
+* and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)
*
* If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or
-* B*A*x = lambda*x, and A is overwritten by U*A*U` or L'*A*L.
+* B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H *A*L.
*
-* B must have been previously factorized as U'*U or L*L' by CPOTRF.
+* B must have been previously factorized as U**H *U or L*L**H by ZPOTRF.
*
* Arguments
* =========
*
* ITYPE (input) INTEGER
-* = 1: compute inv(U')*A*inv(U) or inv(L)*A*inv(L');
-* = 2 or 3: compute U*A*U' or L'*A*L.
+* = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H);
+* = 2 or 3: compute U*A*U**H or L**H *A*L.
*
* UPLO (input) CHARACTER*1
* Specifies whether the upper or lower triangular part of the
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**H)*A*inv(U)
*
DO 10 K = 1, N
*
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**H)
*
DO 20 K = 1, N
*
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**H
*
DO 30 K = 1, N
*
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**H *A*L
*
DO 40 K = 1, N
*
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**H)*A*inv(U)
*
DO 10 K = 1, N, NB
KB = MIN( N-K+1, NB )
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**H)
*
DO 20 K = 1, N, NB
KB = MIN( N-K+1, NB )
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**H
*
DO 30 K = 1, N, NB
KB = MIN( N-K+1, NB )
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**H*A*L
*
DO 40 K = 1, N, NB
KB = MIN( N-K+1, NB )
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H*y
*
IF( UPPER ) THEN
TRANS = 'C'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H *y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H *y
*
IF( UPPER ) THEN
TRANS = 'C'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H*y
*
IF( UPPER ) THEN
TRANS = 'C'
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**H or A = L*D*L**H.
*
CALL CHETRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**H or A = L*D*L**H.
*
CALL CLACPY( UPLO, N, N, A, LDA, AF, LDAF )
CALL CHETRF( UPLO, N, AF, LDAF, IPIV, WORK, LWORK, INFO )
*
* CHETD2 reduces a complex Hermitian matrix A to real symmetric
* tridiagonal form T by a unitary similarity transformation:
-* Q' * A * Q = T.
+* Q**H * A * Q = T.
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i),
A( N, N ) = REAL( A( N, N ) )
DO 10 I = N - 1, 1, -1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**H
* to annihilate A(1:i-1,i+1)
*
ALPHA = A( I, I+1 )
CALL CHEMV( UPLO, I, TAUI, A, LDA, A( 1, I+1 ), 1, ZERO,
$ TAU, 1 )
*
-* Compute w := x - 1/2 * tau * (x'*v) * v
+* Compute w := x - 1/2 * tau * (x**H * v) * v
*
ALPHA = -HALF*TAUI*CDOTC( I, TAU, 1, A( 1, I+1 ), 1 )
CALL CAXPY( I, ALPHA, A( 1, I+1 ), 1, TAU, 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v'
+* A := A - v * w**H - w * v**H
*
CALL CHER2( UPLO, I, -ONE, A( 1, I+1 ), 1, TAU, 1, A,
$ LDA )
A( 1, 1 ) = REAL( A( 1, 1 ) )
DO 20 I = 1, N - 1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**H
* to annihilate A(i+2:n,i)
*
ALPHA = A( I+1, I )
CALL CHEMV( UPLO, N-I, TAUI, A( I+1, I+1 ), LDA,
$ A( I+1, I ), 1, ZERO, TAU( I ), 1 )
*
-* Compute w := x - 1/2 * tau * (x'*v) * v
+* Compute w := x - 1/2 * tau * (x**H * v) * v
*
ALPHA = -HALF*TAUI*CDOTC( N-I, TAU( I ), 1, A( I+1, I ),
$ 1 )
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'
+* A := A - v * w' - w * v**H
*
CALL CHER2( UPLO, N-I, -ONE, A( I+1, I ), 1, TAU( I ), 1,
$ A( I+1, I+1 ), LDA )
* CHETF2 computes the factorization of a complex Hermitian matrix A
* using the Bunch-Kaufman diagonal pivoting method:
*
-* A = U*D*U' or A = L*D*L'
+* A = U*D*U**H or A = L*D*L**H
*
* where U (or L) is a product of permutation and unit upper (lower)
-* triangular matrices, U' is the conjugate transpose of U, and D is
+* triangular matrices, U**H is the conjugate transpose of U, and D is
* Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* J. Lewis, Boeing Computer Services Company
* A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**H, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**H, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**H using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**H = A - W(k)*1/D(k)*W(k)**H
*
R1 = ONE / REAL( A( K, K ) )
CALL CHER( UPLO, K-1, -R1, A( 1, K ), 1, A, LDA )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**H
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**H
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**H using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**H = A - W(k)*(1/D(k))*W(k)**H
*
R1 = ONE / REAL( A( K, K ) )
CALL CHER( UPLO, N-K, -R1, A( K+1, K ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )'
-* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )'
+* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )**H
+* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )**H
*
* where L(k) and L(k+1) are the k-th and (k+1)-th
* columns of L
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i),
$ LDWORK )
*
* Update the unreduced submatrix A(1:i-1,1:i-1), using an
-* update of the form: A := A - V*W' - W*V'
+* update of the form: A := A - V*W' - 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'
+* an update of the form: A := A - V*W' - W*V**H
*
CALL CHER2K( UPLO, 'No transpose', N-I-NB+1, NB, -CONE,
$ A( I+NB, I ), LDA, WORK( NB+1 ), LDWORK, ONE,
* Further Details
* ===============
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**H, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**H, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**H using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* KB, where KB is the number of columns factorized by CLAHEF;
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**H using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* KB, where KB is the number of columns factorized by CLAHEF;
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**H.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**H.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
IF( UPPER ) THEN
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**H)*inv(D)*inv(U)*P'.
*
CALL CTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**H) = (inv(U))**H
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**H)*inv(D)*inv(U)
*
CUT=N
DO WHILE (CUT .GT. 0)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**H)*inv(D)*inv(U) *P'
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**H)*inv(D)*inv(U)*P'.
*
CALL CTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**H) = (inv(U))**H
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**H)*inv(D)*inv(U)
*
CUT=0
DO WHILE (CUT .LT. N)
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**H)*inv(D)*inv(U) *P'
*
I=N
DO WHILE ( I .GE. 1 )
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**H.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**H *X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**H(K)), where U(K) is the transformation
* stored in column K of A.
*
IF( K.GT.1 ) THEN
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**H(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
IF( K.GT.1 ) THEN
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**H.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**H *X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**H(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N ) THEN
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**H(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
* Purpose
* =======
*
-* CHETRS2 solves a system of linear equations A*X = B with a COMPLEX
-* Hermitian matrix A using the factorization A = U*D*U**T or
-* A = L*D*L**T computed by CSYTRF and converted by CSYCONV.
+* CHETRS2 solves a system of linear equations A*X = B with a complex
+* Hermitian matrix A using the factorization A = U*D*U**H or
+* A = L*D*L**H computed by CHETRF and converted by CSYCONV.
*
* Arguments
* =========
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**H.
*
-* P' * B
+* P**T * B
K=N
DO WHILE ( K .GE. 1 )
IF( IPIV( K ).GT.0 ) THEN
END IF
END DO
*
-* Compute (U \P' * B) -> B [ (U \P' * B) ]
+* Compute (U \P**T * B) -> B [ (U \P**T * B) ]
*
CALL CTRSM('L','U','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (U \P' * B) ]
+* Compute D \ B -> B [ D \ (U \P**T * B) ]
*
I=N
DO WHILE ( I .GE. 1 )
I = I - 1
END DO
*
-* Compute (U' \ B) -> B [ U' \ (D \ (U \P' * B) ) ]
+* Compute (U**H \ B) -> B [ U**H \ (D \ (U \P**T * B) ) ]
*
CALL CTRSM('L','U','C','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (U' \ (D \ (U \P' * B) )) ]
+* P * B [ P * (U**H \ (D \ (U \P**T * B) )) ]
*
K=1
DO WHILE ( K .LE. N )
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**H.
*
-* P' * B
+* P**T * B
K=1
DO WHILE ( K .LE. N )
IF( IPIV( K ).GT.0 ) THEN
ENDIF
END DO
*
-* Compute (L \P' * B) -> B [ (L \P' * B) ]
+* Compute (L \P**T * B) -> B [ (L \P**T * B) ]
*
CALL CTRSM('L','L','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (L \P' * B) ]
+* Compute D \ B -> B [ D \ (L \P**T * B) ]
*
I=1
DO WHILE ( I .LE. N )
I = I + 1
END DO
*
-* Compute (L' \ B) -> B [ L' \ (D \ (L \P' * B) ) ]
+* Compute (L**H \ B) -> B [ L**H \ (D \ (L \P**T * B) ) ]
*
CALL CTRSM('L','L','C','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (L' \ (D \ (L \P' * B) )) ]
+* P * B [ P * (L**H \ (D \ (L \P**T * B) )) ]
*
K=N
DO WHILE ( K .GE. 1 )
CALL CLACN2( N, WORK( N+1 ), WORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**H) or inv(U*D*U**H).
*
CALL CHPTRS( UPLO, N, 1, AP, IPIV, WORK, N, INFO )
GO TO 30
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**H)*A*inv(U)
*
* J1 and JJ are the indices of A(1,j) and A(j,j)
*
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**H)
*
* KK and K1K1 are the indices of A(k,k) and A(k+1,k+1)
*
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**H
*
* K1 and KK are the indices of A(1,k) and A(k,k)
*
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**H *A*L
*
* JJ and J1J1 are the indices of A(j,j) and A(j+1,j+1)
*
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H*y
*
IF( UPPER ) THEN
TRANS = 'C'
LIWMIN = 1
END IF
END IF
+*
WORK( 1 ) = LWMIN
RWORK( 1 ) = LRWMIN
IWORK( 1 ) = LIWMIN
-*
IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
INFO = -11
ELSE IF( LRWORK.LT.LRWMIN .AND. .NOT.LQUERY ) THEN
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H *y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H *y
*
IF( UPPER ) THEN
TRANS = 'C'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H*y
*
IF( UPPER ) THEN
TRANS = 'C'
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**H or A = L*D*L**H.
*
CALL CHPTRF( UPLO, N, AP, IPIV, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**H or A = L*D*L**H.
*
CALL CCOPY( N*( N+1 ) / 2, AP, 1, AFP, 1 )
CALL CHPTRF( UPLO, N, AFP, IPIV, INFO )
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in AP,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in AP,
AP( I1+N-1 ) = REAL( AP( I1+N-1 ) )
DO 10 I = N - 1, 1, -1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**H
* to annihilate A(1:i-1,i+1)
*
ALPHA = AP( I1+I-1 )
CALL CHPMV( UPLO, I, TAUI, AP, AP( I1 ), 1, ZERO, TAU,
$ 1 )
*
-* Compute w := y - 1/2 * tau * (y'*v) * v
+* Compute w := y - 1/2 * tau * (y**H *v) * v
*
ALPHA = -HALF*TAUI*CDOTC( I, TAU, 1, AP( I1 ), 1 )
CALL CAXPY( I, ALPHA, AP( I1 ), 1, TAU, 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v'
+* A := A - v * w**H - w * v**H
*
CALL CHPR2( UPLO, I, -ONE, AP( I1 ), 1, TAU, 1, AP )
*
DO 20 I = 1, N - 1
I1I1 = II + N - I + 1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**H
* to annihilate A(i+2:n,i)
*
ALPHA = AP( II+1 )
CALL CHPMV( UPLO, N-I, TAUI, AP( I1I1 ), AP( II+1 ), 1,
$ ZERO, TAU( I ), 1 )
*
-* Compute w := y - 1/2 * tau * (y'*v) * v
+* Compute w := y - 1/2 * tau * (y**H *v) * v
*
ALPHA = -HALF*TAUI*CDOTC( N-I, TAU( I ), 1, AP( II+1 ),
$ 1 )
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'
+* A := A - v * w' - w * v**H
*
CALL CHPR2( UPLO, N-I, -ONE, AP( II+1 ), 1, TAU( I ), 1,
$ AP( I1I1 ) )
* 5-96 - Based on modifications by J. Lewis, Boeing Computer Services
* Company
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**H, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**H, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**H using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**H = A - W(k)*1/D(k)*W(k)**H
*
R1 = ONE / REAL( AP( KC+K-1 ) )
CALL CHPR( UPLO, K-1, -R1, AP( KC ), 1, AP )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**H
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**H
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**H using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**H = A - W(k)*(1/D(k))*W(k)**H
*
R1 = ONE / REAL( AP( KC ) )
CALL CHPR( UPLO, N-K, -R1, AP( KC+1 ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )'
-* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )'
+* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )**H
+* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )**H
*
* where L(k) and L(k+1) are the k-th and (k+1)-th
* columns of L
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**H.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**H.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**H.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**H *X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**H(K)), where U(K) is the transformation
* stored in column K of A.
*
IF( K.GT.1 ) THEN
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**H(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
IF( K.GT.1 ) THEN
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**H.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**H *X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**H(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N ) THEN
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**H(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
* -- Univ. of California Berkeley and NAG Ltd. --
*
IMPLICIT NONE
-*
+* ..
* .. Scalar Arguments ..
REAL ALPHA, BETA
INTEGER INCX, INCY, LDAB, M, N, KL, KU, TRANS
* Purpose
* =======
*
-* SLA_GBAMV performs one of the matrix-vector operations
+* CLA_GBAMV performs one of the matrix-vector operations
*
* y := alpha*abs(A)*abs(x) + beta*abs(y),
-* or y := alpha*abs(A)'*abs(x) + beta*abs(y),
+* or y := alpha*abs(A)**T*abs(x) + beta*abs(y),
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
* follows:
*
* BLAS_NO_TRANS y := alpha*abs(A)*abs(x) + beta*abs(y)
-* BLAS_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
-* BLAS_CONJ_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
+* BLAS_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
+* BLAS_CONJ_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
*
* Unchanged on exit.
*
-* M (input) INTEGER
+* M (input) INTEGER
* On entry, M specifies the number of rows of the matrix A.
* M must be at least zero.
* Unchanged on exit.
*
-* N (input) INTEGER
+* N (input) INTEGER
* On entry, N specifies the number of columns of the matrix A.
* N must be at least zero.
* Unchanged on exit.
*
-* KL (input) INTEGER
+* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
-* KU (input) INTEGER
+* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
-* ALPHA (input) REAL
+* ALPHA (input) REAL
* On entry, ALPHA specifies the scalar alpha.
* Unchanged on exit.
*
-* A (input) REAL array, dimension (LDA,n)
-* Before entry, the leading m by n part of the array A must
+* AB (input) REAL array, dimension (LDAB,n)
+* Before entry, the leading m by n part of the array AB must
* contain the matrix of coefficients.
* Unchanged on exit.
*
-* LDA (input) INTEGER
-* On entry, LDA specifies the first dimension of A as declared
-* in the calling (sub) program. LDA must be at least
+* LDAB (input) INTEGER
+* On entry, LDAB specifies the first dimension of AB as declared
+* in the calling (sub) program. LDAB must be at least
* max( 1, m ).
* Unchanged on exit.
*
-* X (input) REAL array, dimension at least
+* X (input) REAL array, dimension
* ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
* vector x.
* Unchanged on exit.
*
-* INCX (input) INTEGER
+* INCX (input) INTEGER
* On entry, INCX specifies the increment for the elements of
* X. INCX must not be zero.
* Unchanged on exit.
*
-* BETA (input) REAL
+* BETA (input) REAL
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input.
* Unchanged on exit.
*
-* Y (input/output) REAL array, dimension at least
+* Y (input/output) REAL array, dimension
* ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
* must contain the vector y. On exit, Y is overwritten by the
* updated vector y.
*
-* INCY (input) INTEGER
+* INCY (input) INTEGER
* On entry, INCY specifies the increment for the elements of
* Y. INCY must not be zero.
* Unchanged on exit.
* CLA_GEAMV performs one of the matrix-vector operations
*
* y := alpha*abs(A)*abs(x) + beta*abs(y),
-* or y := alpha*abs(A)'*abs(x) + beta*abs(y),
+* or y := alpha*abs(A)**T*abs(x) + beta*abs(y),
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
* follows:
*
* BLAS_NO_TRANS y := alpha*abs(A)*abs(x) + beta*abs(y)
-* BLAS_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
-* BLAS_CONJ_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
+* BLAS_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
+* BLAS_CONJ_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
*
* Unchanged on exit.
*
-* M (input) INTEGER
+* M (input) INTEGER
* On entry, M specifies the number of rows of the matrix A.
* M must be at least zero.
* Unchanged on exit.
*
-* N (input) INTEGER
+* N (input) INTEGER
* On entry, N specifies the number of columns of the matrix A.
* N must be at least zero.
* Unchanged on exit.
*
-* ALPHA (input) REAL
+* ALPHA (input) REAL
* On entry, ALPHA specifies the scalar alpha.
* Unchanged on exit.
*
-* A (input) COMPLEX array, dimension (LDA,n)
+* A (input) COMPLEX array, dimension (LDA,n)
* Before entry, the leading m by n part of the array A must
* contain the matrix of coefficients.
* Unchanged on exit.
*
-* LDA (input) INTEGER
+* LDA (input) INTEGER
* On entry, LDA specifies the first dimension of A as declared
* in the calling (sub) program. LDA must be at least
* max( 1, m ).
* Unchanged on exit.
*
-* X (input) COMPLEX array, dimension
+* X (input) COMPLEX array, dimension
* ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
* vector x.
* Unchanged on exit.
*
-* INCX (input) INTEGER
+* INCX (input) INTEGER
* On entry, INCX specifies the increment for the elements of
* X. INCX must not be zero.
* Unchanged on exit.
*
-* BETA (input) REAL
+* BETA (input) REAL
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input.
* Unchanged on exit.
*
-* Y (input/output) REAL array, dimension
+* Y (input/output) REAL array, dimension
* ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
* must contain the vector y. On exit, Y is overwritten by the
* updated vector y.
*
-* INCY (input) INTEGER
+* INCY (input) INTEGER
* On entry, INCY specifies the increment for the elements of
* Y. INCY must not be zero.
* Unchanged on exit.
*
* CLABRD reduces the first NB rows and columns of a complex general
* m by n matrix A to upper or lower real bidiagonal form by a unitary
-* transformation Q' * A * P, and returns the matrices X and Y which
+* transformation Q**H * A * P, and returns the matrices X and Y which
* are needed to apply the transformation to the unreduced part of A.
*
* If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**H and G(i) = I - taup * u * u**H
*
* where tauq and taup are complex scalars, and v and u are complex
* vectors.
* A(i,i+1:n); tauq is stored in TAUQ(i) and taup in TAUP(i).
*
* The elements of the vectors v and u together form the m-by-nb matrix
-* V and the nb-by-n matrix U' which are needed, with X and Y, to apply
+* V and the nb-by-n matrix U**H which are needed, with X and Y, to apply
* the transformation to the unreduced part of the matrix, using a block
-* update of the form: A := A - V*Y' - X*U'.
+* update of the form: A := A - V*Y**H - X*U**H.
*
* The contents of A on exit are illustrated by the following examples
* with nb = 2:
* eigenvalues and optionally eigenvectors of a dense or banded
* Hermitian matrix that has been reduced to tridiagonal form.
*
-* T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)
+* T = Q(in) ( D(in) + RHO * Z*Z**H ) Q**H(in) = Q(out) * D(out) * Q**H(out)
*
-* where Z = Q'u, u is a vector of length N with ones in the
+* where Z = Q**Hu, u is a vector of length N with ones in the
* CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.
*
* The eigenvectors of the original matrix are stored in Q, and the
DO 110 ITS = 1, N
*
* Solve U*x = scale*v for a right eigenvector
-* or U'*x = scale*v for a left eigenvector,
+* or U**H *x = scale*v for a left eigenvector,
* overwriting x on v.
*
CALL CLATRS( 'Upper', TRANS, 'Nonunit', NORMIN, N, B, LDB, V,
* CLAGS2 computes 2-by-2 unitary matrices U, V and Q, such
* that if ( UPPER ) then
*
-* U'*A*Q = U'*( A1 A2 )*Q = ( x 0 )
-* ( 0 A3 ) ( x x )
+* U**H *A*Q = U**H *( A1 A2 )*Q = ( x 0 )
+* ( 0 A3 ) ( x x )
* and
-* V'*B*Q = V'*( B1 B2 )*Q = ( x 0 )
-* ( 0 B3 ) ( x x )
+* V**H*B*Q = V**H *( B1 B2 )*Q = ( x 0 )
+* ( 0 B3 ) ( x x )
*
* or if ( .NOT.UPPER ) then
*
-* U'*A*Q = U'*( A1 0 )*Q = ( x x )
-* ( A2 A3 ) ( 0 x )
+* U**H *A*Q = U**H *( A1 0 )*Q = ( x x )
+* ( A2 A3 ) ( 0 x )
* and
-* V'*B*Q = V'*( B1 0 )*Q = ( x x )
-* ( B2 B3 ) ( 0 x )
+* V**H *B*Q = V**H *( B1 0 )*Q = ( x x )
+* ( B2 B3 ) ( 0 x )
* where
*
-* U = ( CSU SNU ), V = ( CSV SNV ),
-* ( -CONJG(SNU) CSU ) ( -CONJG(SNV) CSV )
+* U = ( CSU SNU ), V = ( CSV SNV ),
+* ( -SNU**H CSU ) ( -SNV**H CSV )
*
-* Q = ( CSQ SNQ )
-* ( -CONJG(SNQ) CSQ )
-*
-* Z' denotes the conjugate transpose of Z.
+* Q = ( CSQ SNQ )
+* ( -SNQ**H CSQ )
*
* The rows of the transformed A and B are parallel. Moreover, if the
* input 2-by-2 matrix A is not zero, then the transformed (1,1) entry
IF( ABS( CSL ).GE.ABS( SNL ) .OR. ABS( CSR ).GE.ABS( SNR ) )
$ THEN
*
-* Compute the (1,1) and (1,2) elements of U'*A and V'*B,
-* and (1,2) element of |U|'*|A| and |V|'*|B|.
+* Compute the (1,1) and (1,2) elements of U**H *A and V**H *B,
+* and (1,2) element of |U|**H *|A| and |V|**H *|B|.
*
UA11R = CSL*A1
UA12 = CSL*A2 + D1*SNL*A3
AUA12 = ABS( CSL )*ABS1( A2 ) + ABS( SNL )*ABS( A3 )
AVB12 = ABS( CSR )*ABS1( B2 ) + ABS( SNR )*ABS( B3 )
*
-* zero (1,2) elements of U'*A and V'*B
+* zero (1,2) elements of U**H *A and V**H *B
*
IF( ( ABS( UA11R )+ABS1( UA12 ) ).EQ.ZERO ) THEN
CALL CLARTG( -CMPLX( VB11R ), CONJG( VB12 ), CSQ, SNQ,
*
ELSE
*
-* Compute the (2,1) and (2,2) elements of U'*A and V'*B,
-* and (2,2) element of |U|'*|A| and |V|'*|B|.
+* Compute the (2,1) and (2,2) elements of U**H *A and V**H *B,
+* and (2,2) element of |U|**H *|A| and |V|**H *|B|.
*
UA21 = -CONJG( D1 )*SNL*A1
UA22 = -CONJG( D1 )*SNL*A2 + CSL*A3
AUA22 = ABS( SNL )*ABS1( A2 ) + ABS( CSL )*ABS( A3 )
AVB22 = ABS( SNR )*ABS1( B2 ) + ABS( CSR )*ABS( B3 )
*
-* zero (2,2) elements of U'*A and V'*B, and then swap.
+* zero (2,2) elements of U**H *A and V**H *B, and then swap.
*
IF( ( ABS1( UA21 )+ABS1( UA22 ) ).EQ.ZERO ) THEN
CALL CLARTG( -CONJG( VB21 ), CONJG( VB22 ), CSQ, SNQ, R )
IF( ABS( CSR ).GE.ABS( SNR ) .OR. ABS( CSL ).GE.ABS( SNL ) )
$ THEN
*
-* Compute the (2,1) and (2,2) elements of U'*A and V'*B,
-* and (2,1) element of |U|'*|A| and |V|'*|B|.
+* Compute the (2,1) and (2,2) elements of U**H *A and V**H *B,
+* and (2,1) element of |U|**H *|A| and |V|**H *|B|.
*
UA21 = -D1*SNR*A1 + CSR*A2
UA22R = CSR*A3
AUA21 = ABS( SNR )*ABS( A1 ) + ABS( CSR )*ABS1( A2 )
AVB21 = ABS( SNL )*ABS( B1 ) + ABS( CSL )*ABS1( B2 )
*
-* zero (2,1) elements of U'*A and V'*B.
+* zero (2,1) elements of U**H *A and V**H *B.
*
IF( ( ABS1( UA21 )+ABS( UA22R ) ).EQ.ZERO ) THEN
CALL CLARTG( CMPLX( VB22R ), VB21, CSQ, SNQ, R )
*
ELSE
*
-* Compute the (1,1) and (1,2) elements of U'*A and V'*B,
-* and (1,1) element of |U|'*|A| and |V|'*|B|.
+* Compute the (1,1) and (1,2) elements of U**H *A and V**H *B,
+* and (1,1) element of |U|**H *|A| and |V|**H *|B|.
*
UA11 = CSR*A1 + CONJG( D1 )*SNR*A2
UA12 = CONJG( D1 )*SNR*A3
AUA11 = ABS( CSR )*ABS( A1 ) + ABS( SNR )*ABS1( A2 )
AVB11 = ABS( CSL )*ABS( B1 ) + ABS( SNL )*ABS1( B2 )
*
-* zero (1,1) elements of U'*A and V'*B, and then swap.
+* zero (1,1) elements of U**H *A and V**H *B, and then swap.
*
IF( ( ABS1( UA11 )+ABS1( UA12 ) ).EQ.ZERO ) THEN
CALL CLARTG( VB12, VB11, CSQ, SNQ, R )
120 CONTINUE
ELSE IF( LSAME( TRANS, 'T' ) ) THEN
*
-* Compute B := B - A'*X
+* Compute B := B - A**T*X
*
DO 140 J = 1, NRHS
IF( N.EQ.1 ) THEN
140 CONTINUE
ELSE IF( LSAME( TRANS, 'C' ) ) THEN
*
-* Compute B := B - A'*X
+* Compute B := B - A**H*X
*
DO 160 J = 1, NRHS
IF( N.EQ.1 ) THEN
* matrix A using the Bunch-Kaufman diagonal pivoting method. The
* partial factorization has the form:
*
-* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
-* ( 0 U22 ) ( 0 D ) ( U12' U22' )
+* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
+* ( 0 U22 ) ( 0 D ) ( U12**H U22**H )
*
-* A = ( L11 0 ) ( D 0 ) ( L11' L21' ) if UPLO = 'L'
-* ( L21 I ) ( 0 A22 ) ( 0 I )
+* A = ( L11 0 ) ( D 0 ) ( L11**H L21**H ) if UPLO = 'L'
+* ( L21 I ) ( 0 A22 ) ( 0 I )
*
* where the order of D is at most NB. The actual order is returned in
* the argument KB, and is either NB or NB-1, or N if N <= NB.
-* Note that U' denotes the conjugate transpose of U.
+* Note that U**H denotes the conjugate transpose of U.
*
* CLAHEF is an auxiliary routine called by CHETRF. It uses blocked code
* (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or
*
* Update the upper triangle of A11 (= A(1:k,1:k)) as
*
-* A11 := A11 - U12*D*U12' = A11 - U12*W'
+* A11 := A11 - U12*D*U12**H = A11 - U12*W**H
*
* computing blocks of NB columns at a time (note that conjg(W) is
* actually stored)
*
* Update the lower triangle of A22 (= A(k:n,k:n)) as
*
-* A22 := A22 - L21*D*L21' = A22 - L21*W'
+* A22 := A22 - L21*D*L21**H = A22 - L21*W**H
*
* computing blocks of NB columns at a time (note that conjg(W) is
* actually stored)
SUBROUTINE CLAHR2( N, K, NB, A, LDA, TAU, T, LDT, Y, LDY )
*
* -- LAPACK auxiliary routine (version 3.2.1) --
-* -- LAPACK is a software package provided by Univ. of Tennessee, --* -- April 2009 --
+* -- LAPACK is a software package provided by Univ. of Tennessee, --
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
+* -- April 2009 --
*
* .. Scalar Arguments ..
INTEGER K, LDA, LDT, LDY, N, NB
* CLAHR2 reduces the first NB columns of A complex general n-BY-(n-k+1)
* matrix A so that elements below the k-th subdiagonal are zero. The
* reduction is performed by an unitary similarity transformation
-* Q' * A * Q. The routine returns the matrices V and T which determine
-* Q as a block reflector I - V*T*V', and also the matrix Y = A * V * T.
+* Q**H * A * Q. The routine returns the matrices V and T which determine
+* Q as a block reflector I - V*T*v**H, and also the matrix Y = A * V * T.
*
* This is an auxiliary routine called by CGEHRD.
*
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit in
* The elements of the vectors v together form the (n-k+1)-by-nb matrix
* V which is needed, with T and Y, to apply the transformation to the
* unreduced part of the matrix, using an update of the form:
-* A := (I - V*T*V') * (A - Y*V').
+* A := (I - V*T*V**H) * (A - Y*V**H).
*
* The contents of A on exit are illustrated by the following example
* with n = 7, k = 3 and nb = 2:
*
* Update A(K+1:N,I)
*
-* Update I-th column of A - Y * V'
+* Update I-th column of A - Y * V**H
*
CALL CLACGV( I-1, A( K+I-1, 1 ), LDA )
CALL CGEMV( 'NO TRANSPOSE', N-K, I-1, -ONE, Y(K+1,1), LDY,
$ 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' to this column (call it b) from the
+* Apply I - V * T' * 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)
$ I-1, A( K+1, 1 ),
$ LDA, T( 1, NB ), 1 )
*
-* w := w + V2'*b2
+* w := w + V2**H * b2
*
CALL CGEMV( 'Conjugate transpose', N-K-I+1, I-1,
$ ONE, A( K+I, 1 ),
$ LDA, A( K+I, I ), 1, ONE, T( 1, NB ), 1 )
*
-* w := T'*w
+* w := T**H * w
*
CALL CTRMV( 'Upper', 'Conjugate transpose', 'NON-UNIT',
$ I-1, T, LDT,
* CLAHRD reduces the first NB columns of a complex general n-by-(n-k+1)
* matrix A so that elements below the k-th subdiagonal are zero. The
* reduction is performed by a unitary similarity transformation
-* Q' * A * Q. The routine returns the matrices V and T which determine
-* Q as a block reflector I - V*T*V', and also the matrix Y = A * V * T.
+* Q**H * A * Q. The routine returns the matrices V and T which determine
+* Q as a block reflector I - V*T*V**H, and also the matrix Y = A * V * T.
*
* This is an OBSOLETE auxiliary routine.
* This routine will be 'deprecated' in a future release.
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit in
* The elements of the vectors v together form the (n-k+1)-by-nb matrix
* V which is needed, with T and Y, to apply the transformation to the
* unreduced part of the matrix, using an update of the form:
-* A := (I - V*T*V') * (A - Y*V').
+* A := (I - V*T*V**H) * (A - Y*V**H).
*
* The contents of A on exit are illustrated by the following example
* with n = 7, k = 3 and nb = 2:
*
* Update A(1:n,i)
*
-* Compute i-th column of A - Y * V'
+* Compute i-th column of A - Y * V**H
*
CALL CLACGV( I-1, A( K+I-1, 1 ), LDA )
CALL CGEMV( 'No transpose', N, I-1, -ONE, Y, LDY,
$ A( K+I-1, 1 ), LDA, ONE, A( 1, I ), 1 )
CALL CLACGV( I-1, A( K+I-1, 1 ), LDA )
*
-* Apply I - V * T' * V' 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', I-1,
$ A( K+1, 1 ), LDA, T( 1, NB ), 1 )
*
-* w := w + V2'*b2
+* w := w + V2**H *b2
*
CALL CGEMV( 'Conjugate transpose', N-K-I+1, I-1, ONE,
$ A( K+I, 1 ), LDA, A( K+I, I ), 1, ONE,
$ T( 1, NB ), 1 )
*
-* w := T'*w
+* w := T**H *w
*
CALL CTRMV( 'Upper', 'Conjugate transpose', 'Non-unit', I-1,
$ T, LDT, T( 1, NB ), 1 )
* diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ]
* [ conjg(gamma) ]
*
-* where alpha = conjg(x)'*w.
+* where alpha = x**H*w.
*
* Arguments
* =========
END IF
*
* In the real version, B is passed to SLASDQ and multiplied
-* internally by Q'. Here B is complex and that product is
+* internally by Q**H. Here B is complex and that product is
* computed below in two steps (real and imaginary parts).
*
J = IRWB - 1
END IF
*
* In the real version, B is passed to SLASDQ and multiplied
-* internally by Q'. Here B is complex and that product is
+* internally by Q**H. Here B is complex and that product is
* computed below in two steps (real and imaginary parts).
*
J = IRWB - 1
* if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
*
* On exit, if INFO = 0, the triangular factor U or L from the
-* Cholesky factorization A = U'*U or A = L*L' of the band
+* Cholesky factorization A = U**H *U or A = L*L**H of the band
* matrix A, in the same storage format as A.
*
* LDAB (input) INTEGER
*
IF( I.LT.N ) THEN
*
-* Apply H(i)' to A(offset+i:m,i+1:n) from the left.
+* Apply H(i)**H to A(offset+i:m,i+1:n) from the left.
*
AII = A( OFFPI, I )
A( OFFPI, I ) = CONE
* Auxiliar vector.
*
* F (input/output) COMPLEX array, dimension (LDF,NB)
-* Matrix F' = L*Y'*A.
+* Matrix F**H = L * Y**H * A.
*
* LDF (input) INTEGER
* The leading dimension of the array F. LDF >= max(1,N).
END IF
*
* Apply previous Householder reflectors to column K:
-* A(RK:M,K) := A(RK:M,K) - A(RK:M,1:K-1)*F(K,1:K-1)'.
+* A(RK:M,K) := A(RK:M,K) - A(RK:M,1:K-1)*F(K,1:K-1)**H.
*
IF( K.GT.1 ) THEN
DO 20 J = 1, K - 1
*
* Compute Kth column of F:
*
-* Compute F(K+1:N,K) := tau(K)*A(RK:M,K+1:N)'*A(RK:M,K).
+* Compute F(K+1:N,K) := tau(K)*A(RK:M,K+1:N)**H*A(RK:M,K).
*
IF( K.LT.N ) THEN
CALL CGEMV( 'Conjugate transpose', M-RK+1, N-K, TAU( K ),
40 CONTINUE
*
* Incremental updating of F:
-* F(1:N,K) := F(1:N,K) - tau(K)*F(1:N,1:K-1)*A(RK:M,1:K-1)'
+* F(1:N,K) := F(1:N,K) - tau(K)*F(1:N,1:K-1)*A(RK:M,1:K-1)**H
* *A(RK:M,K).
*
IF( K.GT.1 ) THEN
END IF
*
* Update the current row of A:
-* A(RK,K+1:N) := A(RK,K+1:N) - A(RK,1:K)*F(K+1:N,1:K)'.
+* A(RK,K+1:N) := A(RK,K+1:N) - A(RK,1:K)*F(K+1:N,1:K)**H.
*
IF( K.LT.N ) THEN
CALL CGEMM( 'No transpose', 'Conjugate transpose', 1, N-K,
*
* Apply the block reflector to the rest of the matrix:
* A(OFFSET+KB+1:M,KB+1:N) := A(OFFSET+KB+1:M,KB+1:N) -
-* A(OFFSET+KB+1:M,1:KB)*F(KB+1:N,1:KB)'.
+* A(OFFSET+KB+1:M,1:KB)*F(KB+1:N,1:KB)**H.
*
IF( KB.LT.MIN( N, M-OFFSET ) ) THEN
CALL CGEMM( 'No transpose', 'Conjugate transpose', M-RK, N-KB,
* if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
*
* On exit, if INFO = 0, the triangular factor U or L from the
-* Cholesky factorization A = U'*U or A = L*L' of the band
+* Cholesky factorization A = U**T *U or A = L*L**T of the band
* matrix A, in the same storage format as A.
*
* LDAB (input) INTEGER
*
* CLAR1V computes the (scaled) r-th column of the inverse of
* the sumbmatrix in rows B1 through BN of the tridiagonal matrix
-* L D L^T - sigma I. When sigma is close to an eigenvalue, the
+* L D L**T - sigma I. When sigma is close to an eigenvalue, the
* computed vector is an accurate eigenvector. Usually, r corresponds
* to the index where the eigenvector is largest in magnitude.
* The following steps accomplish this computation :
-* (a) Stationary qd transform, L D L^T - sigma I = L(+) D(+) L(+)^T,
-* (b) Progressive qd transform, L D L^T - sigma I = U(-) D(-) U(-)^T,
+* (a) Stationary qd transform, L D L**T - sigma I = L(+) D(+) L(+)**T,
+* (b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,
* (c) Computation of the diagonal elements of the inverse of
-* L D L^T - sigma I by combining the above transforms, and choosing
+* L D L**T - sigma I by combining the above transforms, and choosing
* r as the index where the diagonal of the inverse is (one of the)
* largest in magnitude.
* (d) Computation of the (scaled) r-th column of the inverse using the
* =========
*
* N (input) INTEGER
-* The order of the matrix L D L^T.
+* The order of the matrix L D L**T.
*
* B1 (input) INTEGER
-* First index of the submatrix of L D L^T.
+* First index of the submatrix of L D L**T.
*
* BN (input) INTEGER
-* Last index of the submatrix of L D L^T.
+* Last index of the submatrix of L D L**T.
*
-* LAMBDA (input) REAL
+* LAMBDA (input) REAL
* The shift. In order to compute an accurate eigenvector,
* LAMBDA should be a good approximation to an eigenvalue
-* of L D L^T.
+* of L D L**T.
*
-* L (input) REAL array, dimension (N-1)
+* L (input) REAL array, dimension (N-1)
* The (n-1) subdiagonal elements of the unit bidiagonal matrix
* L, in elements 1 to N-1.
*
-* D (input) REAL array, dimension (N)
+* D (input) REAL array, dimension (N)
* The n diagonal elements of the diagonal matrix D.
*
-* LD (input) REAL array, dimension (N-1)
+* LD (input) REAL array, dimension (N-1)
* The n-1 elements L(i)*D(i).
*
-* LLD (input) REAL array, dimension (N-1)
+* LLD (input) REAL array, dimension (N-1)
* The n-1 elements L(i)*L(i)*D(i).
*
-* PIVMIN (input) REAL
+* PIVMIN (input) REAL
* The minimum pivot in the Sturm sequence.
*
-* GAPTOL (input) REAL
+* GAPTOL (input) REAL
* Tolerance that indicates when eigenvector entries are negligible
* w.r.t. their contribution to the residual.
*
-* Z (input/output) COMPLEX array, dimension (N)
+* Z (input/output) COMPLEX array, dimension (N)
* On input, all entries of Z must be set to 0.
* On output, Z contains the (scaled) r-th column of the
* inverse. The scaling is such that Z(R) equals 1.
*
* NEGCNT (output) INTEGER
* If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin
-* in the matrix factorization L D L^T, and NEGCNT = -1 otherwise.
+* in the matrix factorization L D L**T, and NEGCNT = -1 otherwise.
*
-* ZTZ (output) REAL
+* ZTZ (output) REAL
* The square of the 2-norm of Z.
*
-* MINGMA (output) REAL
+* MINGMA (output) REAL
* The reciprocal of the largest (in magnitude) diagonal
-* element of the inverse of L D L^T - sigma I.
+* element of the inverse of L D L**T - sigma I.
*
* R (input/output) INTEGER
* The twist index for the twisted factorization used to
* compute Z.
* On input, 0 <= R <= N. If R is input as 0, R is set to
-* the index where (L D L^T - sigma I)^{-1} is largest
+* the index where (L D L**T - sigma I)^{-1} is largest
* in magnitude. If 1 <= R <= N, R is unchanged.
* On output, R contains the twist index used to compute Z.
* Ideally, R designates the position of the maximum entry in the
* The support of the vector in Z, i.e., the vector Z is
* nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 ).
*
-* NRMINV (output) REAL
+* NRMINV (output) REAL
* NRMINV = 1/SQRT( ZTZ )
*
-* RESID (output) REAL
+* RESID (output) REAL
* The residual of the FP vector.
* RESID = ABS( MINGMA )/SQRT( ZTZ )
*
-* RQCORR (output) REAL
+* RQCORR (output) REAL
* The Rayleigh Quotient correction to LAMBDA.
* RQCORR = MINGMA*TMP
*
-* WORK (workspace) REAL array, dimension (4*N)
+* WORK (workspace) REAL array, dimension (4*N)
*
* Further Details
* ===============
* matrix C, from either the left or the right. H is represented in the
* form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**H
*
* where tau is a complex scalar and v is a complex vector.
*
* If tau = 0, then H is taken to be the unit matrix.
*
-* To apply H' (the conjugate transpose of H), supply conjg(tau) instead
+* To apply H**H (the conjugate transpose of H), supply conjg(tau) instead
* tau.
*
* Arguments
*
IF( LASTV.GT.0 ) THEN
*
-* w(1:lastc,1) := C(1:lastv,1:lastc)' * v(1:lastv,1)
+* w(1:lastc,1) := C(1:lastv,1:lastc)**H * v(1:lastv,1)
*
CALL CGEMV( 'Conjugate transpose', LASTV, LASTC, ONE,
$ C, LDC, V, INCV, ZERO, WORK, 1 )
*
-* C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)'
+* C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)**H
*
CALL CGERC( LASTV, LASTC, -TAU, V, INCV, WORK, 1, C, LDC )
END IF
CALL CGEMV( 'No transpose', LASTC, LASTV, ONE, C, LDC,
$ V, INCV, ZERO, WORK, 1 )
*
-* C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)'
+* C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)**H
*
CALL CGERC( LASTC, LASTV, -TAU, WORK, 1, V, INCV, C, LDC )
END IF
* Purpose
* =======
*
-* CLARFB applies a complex block reflector H or its transpose H' to a
+* CLARFB applies a complex block reflector H or its transpose H**H to a
* complex M-by-N matrix C, from either the left or the right.
*
* Arguments
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply H or H' from the Left
-* = 'R': apply H or H' from the Right
+* = 'L': apply H or H**H from the Left
+* = 'R': apply H or H**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply H (No transpose)
-* = 'C': apply H' (Conjugate transpose)
+* = 'C': apply H**H (Conjugate transpose)
*
* DIRECT (input) CHARACTER*1
* Indicates how H is formed from a product of elementary
*
* C (input/output) COMPLEX array, dimension (LDC,N)
* On entry, the M-by-N matrix C.
-* On exit, C is overwritten by H*C or H'*C or C*H or C*H'.
+* On exit, C is overwritten by H*C or H**H*C or C*H or C*H**H.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**H * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILACLR( M, K, V, LDV ) )
LASTC = ILACLC( LASTV, N, C, LDC )
*
-* W := C' * V = (C1'*V1 + C2'*V2) (stored in WORK)
+* W := C**H * V = (C1**H * V1 + C2**H * V2) (stored in WORK)
*
* W := C1'
*
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2'*V2
+* W := W + C2**H *V2
*
CALL CGEMM( 'Conjugate transpose', 'No transpose',
$ LASTC, K, LASTV-K, ONE, C( K+1, 1 ), LDC,
$ V( K+1, 1 ), LDV, ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**H or W * T
*
CALL CTRMM( 'Right', 'Upper', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V * W'
+* C := C - V * W**H
*
IF( M.GT.K ) THEN
*
-* C2 := C2 - V2 * W'
+* C2 := C2 - V2 * W**H
*
CALL CGEMM( 'No transpose', 'Conjugate transpose',
$ LASTV-K, LASTC, K, -ONE, V( K+1, 1 ), LDV,
$ WORK, LDWORK, ONE, C( K+1, 1 ), LDC )
END IF
*
-* W := W * V1'
+* W := W * V1**H
*
CALL CTRMM( 'Right', 'Lower', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
-* C1 := C1 - W'
+* C1 := C1 - W**H
*
DO 30 J = 1, K
DO 20 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**H where C = ( C1 C2 )
*
LASTV = MAX( K, ILACLR( N, K, V, LDV ) )
LASTC = ILACLR( M, LASTV, C, LDC )
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**H
*
CALL CTRMM( 'Right', 'Upper', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - W * V'
+* C := C - W * V**H
*
IF( LASTV.GT.K ) THEN
*
-* C2 := C2 - W * V2'
+* C2 := C2 - W * V2**H
*
CALL CGEMM( 'No transpose', 'Conjugate transpose',
$ LASTC, LASTV-K, K,
$ ONE, C( 1, K+1 ), LDC )
END IF
*
-* W := W * V1'
+* W := W * V1**H
*
CALL CTRMM( 'Right', 'Lower', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**H * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILACLR( M, K, V, LDV ) )
LASTC = ILACLC( LASTV, N, C, LDC )
*
-* W := C' * V = (C1'*V1 + C2'*V2) (stored in WORK)
+* W := C**H * V = (C1**H * V1 + C2**H * V2) (stored in WORK)
*
-* W := C2'
+* W := C2**H
*
DO 70 J = 1, K
CALL CCOPY( LASTC, C( LASTV-K+J, 1 ), LDC,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1'*V1
+* W := W + C1**H*V1
*
CALL CGEMM( 'Conjugate transpose', 'No transpose',
$ LASTC, K, LASTV-K, ONE, C, LDC, V, LDV,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**H or W * T
*
CALL CTRMM( 'Right', 'Lower', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V * W'
+* C := C - V * W**H
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - V1 * W'
+* C1 := C1 - V1 * W**H
*
CALL CGEMM( 'No transpose', 'Conjugate transpose',
$ LASTV-K, LASTC, K, -ONE, V, LDV, WORK, LDWORK,
$ ONE, C, LDC )
END IF
*
-* W := W * V2'
+* W := W * V2**H
*
CALL CTRMM( 'Right', 'Upper', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V( LASTV-K+1, 1 ), LDV,
$ WORK, LDWORK )
*
-* C2 := C2 - W'
+* C2 := C2 - W**H
*
DO 90 J = 1, K
DO 80 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**H where C = ( C1 C2 )
*
LASTV = MAX( K, ILACLR( N, K, V, LDV ) )
LASTC = ILACLR( M, LASTV, C, LDC )
$ ONE, C, LDC, V, LDV, ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**H
*
CALL CTRMM( 'Right', 'Lower', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - W * V'
+* C := C - W * V**H
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - W * V1'
+* C1 := C1 - W * V1**H
*
CALL CGEMM( 'No transpose', 'Conjugate transpose',
$ LASTC, LASTV-K, K, -ONE, WORK, LDWORK, V, LDV,
$ ONE, C, LDC )
END IF
*
-* W := W * V2'
+* W := W * V2**H
*
CALL CTRMM( 'Right', 'Upper', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V( LASTV-K+1, 1 ), LDV,
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**H * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILACLC( K, M, V, LDV ) )
LASTC = ILACLC( LASTV, N, C, LDC )
*
-* W := C' * V' = (C1'*V1' + C2'*V2') (stored in WORK)
+* W := C**H * V**H = (C1**H * V1**H + C2**H * V2**H) (stored in WORK)
*
-* W := C1'
+* W := C1**H
*
DO 130 J = 1, K
CALL CCOPY( LASTC, C( J, 1 ), LDC, WORK( 1, J ), 1 )
CALL CLACGV( LASTC, WORK( 1, J ), 1 )
130 CONTINUE
*
-* W := W * V1'
+* W := W * V1**H
*
CALL CTRMM( 'Right', 'Upper', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2'*V2'
+* W := W + C2**H*V2**H
*
CALL CGEMM( 'Conjugate transpose',
$ 'Conjugate transpose', LASTC, K, LASTV-K,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**H or W * T
*
CALL CTRMM( 'Right', 'Upper', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V' * W'
+* C := C - V**H * W**H
*
IF( LASTV.GT.K ) THEN
*
-* C2 := C2 - V2' * W'
+* C2 := C2 - V2**H * W**H
*
CALL CGEMM( 'Conjugate transpose',
$ 'Conjugate transpose', LASTV-K, LASTC, K,
CALL CTRMM( 'Right', 'Upper', 'No transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
-* C1 := C1 - W'
+* C1 := C1 - W**H
*
DO 150 J = 1, K
DO 140 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**H where C = ( C1 C2 )
*
LASTV = MAX( K, ILACLC( K, N, V, LDV ) )
LASTC = ILACLR( M, LASTV, C, LDC )
*
-* W := C * V' = (C1*V1' + C2*V2') (stored in WORK)
+* W := C * V**H = (C1*V1**H + C2*V2**H) (stored in WORK)
*
* W := C1
*
CALL CCOPY( LASTC, C( 1, J ), 1, WORK( 1, J ), 1 )
160 CONTINUE
*
-* W := W * V1'
+* W := W * V1**H
*
CALL CTRMM( 'Right', 'Upper', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2 * V2'
+* W := W + C2 * V2**H
*
CALL CGEMM( 'No transpose', 'Conjugate transpose',
$ LASTC, K, LASTV-K, ONE, C( 1, K+1 ), LDC,
$ V( 1, K+1 ), LDV, ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**H
*
CALL CTRMM( 'Right', 'Upper', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**H * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILACLC( K, M, V, LDV ) )
LASTC = ILACLC( LASTV, N, C, LDC )
*
-* W := C' * V' = (C1'*V1' + C2'*V2') (stored in WORK)
+* W := C**H * V**H = (C1**H * V1**H + C2**H * V2**H) (stored in WORK)
*
-* W := C2'
+* W := C2**H
*
DO 190 J = 1, K
CALL CCOPY( LASTC, C( LASTV-K+J, 1 ), LDC,
CALL CLACGV( LASTC, WORK( 1, J ), 1 )
190 CONTINUE
*
-* W := W * V2'
+* W := W * V2**H
*
CALL CTRMM( 'Right', 'Lower', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1'*V1'
+* W := W + C1**H * V1**H
*
CALL CGEMM( 'Conjugate transpose',
$ 'Conjugate transpose', LASTC, K, LASTV-K,
$ ONE, C, LDC, V, LDV, ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**H or W * T
*
CALL CTRMM( 'Right', 'Lower', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V' * W'
+* C := C - V**H * W**H
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - V1' * W'
+* C1 := C1 - V1**H * W**H
*
CALL CGEMM( 'Conjugate transpose',
$ 'Conjugate transpose', LASTV-K, LASTC, K,
$ LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
*
-* C2 := C2 - W'
+* C2 := C2 - W**H
*
DO 210 J = 1, K
DO 200 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**H where C = ( C1 C2 )
*
LASTV = MAX( K, ILACLC( K, N, V, LDV ) )
LASTC = ILACLR( M, LASTV, C, LDC )
*
-* W := C * V' = (C1*V1' + C2*V2') (stored in WORK)
+* W := C * V**H = (C1*V1**H + C2*V2**H) (stored in WORK)
*
* W := C2
*
$ WORK( 1, J ), 1 )
220 CONTINUE
*
-* W := W * V2'
+* W := W * V2**H
*
CALL CTRMM( 'Right', 'Lower', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1 * V1'
+* W := W + C1 * V1**H
*
CALL CGEMM( 'No transpose', 'Conjugate transpose',
$ LASTC, K, LASTV-K, ONE, C, LDC, V, LDV, ONE,
$ WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**H
*
CALL CTRMM( 'Right', 'Lower', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
* CLARFG generates a complex elementary reflector H of order n, such
* that
*
-* H' * ( alpha ) = ( beta ), H' * H = I.
-* ( x ) ( 0 )
+* H**H * ( alpha ) = ( beta ), H**H * H = I.
+* ( x ) ( 0 )
*
* where alpha and beta are scalars, with beta real, and x is an
* (n-1)-element complex vector. H is represented in the form
*
-* H = I - tau * ( 1 ) * ( 1 v' ) ,
+* H = I - tau * ( 1 ) * ( 1 v**H ) ,
* ( v )
*
* where tau is a complex scalar and v is a complex (n-1)-element
* CLARFGP generates a complex elementary reflector H of order n, such
* that
*
-* H' * ( alpha ) = ( beta ), H' * H = I.
-* ( x ) ( 0 )
+* H**H * ( alpha ) = ( beta ), H**H * H = I.
+* ( x ) ( 0 )
*
* where alpha and beta are scalars, beta is real and non-negative, and
* x is an (n-1)-element complex vector. H is represented in the form
*
-* H = I - tau * ( 1 ) * ( 1 v' ) ,
+* H = I - tau * ( 1 ) * ( 1 v**H ) ,
* ( v )
*
* where tau is a complex scalar and v is a complex (n-1)-element
* 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
*
* Arguments
* =========
END DO
J = MIN( LASTV, PREVLASTV )
*
-* T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)' * V(i:j,i)
+* T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)**H * V(i:j,i)
*
CALL CGEMV( 'Conjugate transpose', J-I+1, I-1,
$ -TAU( I ), V( I, 1 ), LDV, V( I, I ), 1,
END DO
J = MIN( LASTV, PREVLASTV )
*
-* T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)'
+* T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)**H
*
IF( I.LT.J )
$ CALL CLACGV( J-I, V( I, I+1 ), LDV )
J = MAX( LASTV, PREVLASTV )
*
* T(i+1:k,i) :=
-* - tau(i) * V(j:n-k+i,i+1:k)' * V(j:n-k+i,i)
+* - tau(i) * V(j:n-k+i,i+1:k)**H * V(j:n-k+i,i)
*
CALL CGEMV( 'Conjugate transpose', N-K+I-J+1, K-I,
$ -TAU( I ), V( J, I+1 ), LDV, V( J, I ),
J = MAX( LASTV, PREVLASTV )
*
* T(i+1:k,i) :=
-* - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)'
+* - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)**H
*
CALL CLACGV( N-K+I-1-J+1, V( I, J ), LDV )
CALL CGEMV( 'No transpose', K-I, N-K+I-J+1,
* matrix C, from either the left or the right. H is represented in the
* form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**H
*
* where tau is a complex scalar and v is a complex vector.
*
* =======
*
* CLARRV computes the eigenvectors of the tridiagonal matrix
-* T = L D L^T given L, D and APPROXIMATIONS to the eigenvalues of L D L^T.
+* T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T.
* The input eigenvalues should have been computed by SLARRE.
*
* Arguments
* M-by-N matrix C, from either the left or the right. H is represented
* in the form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**H
*
* where tau is a complex scalar and v is a complex vector.
*
* If tau = 0, then H is taken to be the unit matrix.
*
-* To apply H' (the conjugate transpose of H), supply conjg(tau) instead
+* To apply H**H (the conjugate transpose of H), supply conjg(tau) instead
* tau.
*
* H is a product of k elementary reflectors as returned by CTZRZF.
CALL CCOPY( N, C, LDC, WORK, 1 )
CALL CLACGV( N, WORK, 1 )
*
-* w( 1:n ) = conjg( w( 1:n ) + C( m-l+1:m, 1:n )' * v( 1:l ) )
+* w( 1:n ) = conjg( w( 1:n ) + C( m-l+1:m, 1:n )**H * v( 1:l ) )
*
CALL CGEMV( 'Conjugate transpose', L, N, ONE, C( M-L+1, 1 ),
$ LDC, V, INCV, ONE, WORK, 1 )
CALL CAXPY( N, -TAU, WORK, 1, C, LDC )
*
* C( m-l+1:m, 1:n ) = C( m-l+1:m, 1:n ) - ...
-* tau * v( 1:l ) * conjg( w( 1:n )' )
+* tau * v( 1:l ) * w( 1:n )**H
*
CALL CGERU( L, N, -TAU, V, INCV, WORK, 1, C( M-L+1, 1 ),
$ LDC )
CALL CAXPY( M, -TAU, WORK, 1, C, 1 )
*
* C( 1:m, n-l+1:n ) = C( 1:m, n-l+1:n ) - ...
-* tau * w( 1:m ) * v( 1:l )'
+* tau * w( 1:m ) * v( 1:l )**H
*
CALL CGERC( M, L, -TAU, WORK, 1, V, INCV, C( 1, N-L+1 ),
$ LDC )
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply H or H' from the Left
-* = 'R': apply H or H' from the Right
+* = 'L': apply H or H**H from the Left
+* = 'R': apply H or H**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply H (No transpose)
-* = 'C': apply H' (Conjugate transpose)
+* = 'C': apply H**H (Conjugate transpose)
*
* DIRECT (input) CHARACTER*1
* Indicates how H is formed from a product of elementary
*
* C (input/output) COMPLEX array, dimension (LDC,N)
* On entry, the M-by-N matrix C.
-* On exit, C is overwritten by H*C or H'*C or C*H or C*H'.
+* On exit, C is overwritten by H*C or H**H*C or C*H or C*H**H.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C
+* Form H * C or H**H * C
*
-* W( 1:n, 1:k ) = conjg( C( 1:k, 1:n )' )
+* W( 1:n, 1:k ) = C( 1:k, 1:n )**H
*
DO 10 J = 1, K
CALL CCOPY( N, C( J, 1 ), LDC, WORK( 1, J ), 1 )
10 CONTINUE
*
* W( 1:n, 1:k ) = W( 1:n, 1:k ) + ...
-* conjg( C( m-l+1:m, 1:n )' ) * V( 1:k, 1:l )'
+* C( m-l+1:m, 1:n )**H * V( 1:k, 1:l )**T
*
IF( L.GT.0 )
$ CALL CGEMM( 'Transpose', 'Conjugate 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 CTRMM( 'Right', 'Lower', TRANST, 'Non-unit', N, K, ONE, T,
$ LDT, WORK, LDWORK )
*
-* C( 1:k, 1:n ) = C( 1:k, 1:n ) - conjg( W( 1:n, 1:k )' )
+* C( 1:k, 1:n ) = C( 1:k, 1:n ) - W( 1:n, 1:k )**H
*
DO 30 J = 1, N
DO 20 I = 1, K
30 CONTINUE
*
* C( m-l+1:m, 1:n ) = C( m-l+1:m, 1:n ) - ...
-* conjg( V( 1:k, 1:l )' ) * conjg( W( 1:n, 1:k )' )
+* V( 1:k, 1:l )**H * W( 1:n, 1:k )**H
*
IF( L.GT.0 )
$ CALL CGEMM( 'Transpose', 'Transpose', L, N, K, -ONE, V, LDV,
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H'
+* Form C * H or C * H**H
*
* W( 1:m, 1:k ) = C( 1:m, 1:k )
*
40 CONTINUE
*
* W( 1:m, 1:k ) = W( 1:m, 1:k ) + ...
-* C( 1:m, n-l+1:n ) * conjg( V( 1:k, 1:l )' )
+* C( 1:m, n-l+1:n ) * V( 1:k, 1:l )**H
*
IF( L.GT.0 )
$ CALL CGEMM( 'No transpose', 'Transpose', M, K, L, ONE,
$ C( 1, N-L+1 ), LDC, V, LDV, ONE, WORK, LDWORK )
*
* W( 1:m, 1:k ) = W( 1:m, 1:k ) * conjg( T ) or
-* W( 1:m, 1:k ) * conjg( T' )
+* W( 1:m, 1:k ) * T**H
*
DO 50 J = 1, K
CALL CLACGV( K-J+1, T( J, J ), 1 )
*
IF( I.LT.K ) THEN
*
-* T(i+1:k,i) = - tau(i) * V(i+1:k,1:n) * V(i,1:n)'
+* T(i+1:k,i) = - tau(i) * V(i+1:k,1:n) * V(i,1:n)**H
*
CALL CLACGV( N, V( I, 1 ), LDV )
CALL CGEMV( 'No transpose', K-I, N, -TAU( I ),
* A using the Bunch-Kaufman diagonal pivoting method. The partial
* factorization has the form:
*
-* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
-* ( 0 U22 ) ( 0 D ) ( U12' U22' )
+* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
+* ( 0 U22 ) ( 0 D ) ( U12**T U22**T )
*
-* A = ( L11 0 ) ( D 0 ) ( L11' L21' ) if UPLO = 'L'
-* ( L21 I ) ( 0 A22 ) ( 0 I )
+* A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L'
+* ( L21 I ) ( 0 A22 ) ( 0 I )
*
* where the order of D is at most NB. The actual order is returned in
* the argument KB, and is either NB or NB-1, or N if N <= NB.
-* Note that U' denotes the transpose of U.
+* Note that U**T denotes the transpose of U.
*
* CLASYF is an auxiliary routine called by CSYTRF. It uses blocked code
* (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or
*
* Update the upper triangle of A11 (= A(1:k,1:k)) as
*
-* A11 := A11 - U12*D*U12' = A11 - U12*W'
+* A11 := A11 - U12*D*U12**T = A11 - U12*W**T
*
* computing blocks of NB columns at a time
*
*
* Update the lower triangle of A22 (= A(k:n,k:n)) as
*
-* A22 := A22 - L21*D*L21' = A22 - L21*W'
+* A22 := A22 - L21*D*L21**T = A22 - L21*W**T
*
* computing blocks of NB columns at a time
*
*
* CLATRD reduces NB rows and columns of a complex Hermitian matrix A to
* Hermitian tridiagonal form by a unitary similarity
-* transformation Q' * A * Q, and returns the matrices V and W which are
+* transformation Q**H * A * Q, and returns the matrices V and W which are
* needed to apply the transformation to the unreduced part of A.
*
* If UPLO = 'U', CLATRD reduces the last NB rows and columns of a
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(i:n) = 0 and v(i-1) = 1; v(1:i-1) is stored on exit in A(1:i-1,i),
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+1:n) is stored on exit in A(i+1:n,i),
* The elements of the vectors v together form the n-by-nb matrix V
* which is needed, with W, to apply the transformation to the unreduced
* part of the matrix, using a Hermitian rank-2k update of the form:
-* A := A - V*W' - W*V'.
+* A := A - V*W**H - W*V**H.
*
* The contents of A on exit are illustrated by the following examples
* with n = 5 and nb = 2:
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
+* T( k ) = I - tau*u( k )*u( k )**H, u( k ) = ( 1 ),
* ( 0 )
* ( z( k ) )
*
*
* CLATZM applies a Householder matrix generated by CTZRQF to a matrix.
*
-* Let P = I - tau*u*u', u = ( 1 ),
-* ( v )
+* Let P = I - tau*u*u**H, u = ( 1 ),
+* ( v )
* where v is an (m-1) vector if SIDE = 'L', or a (n-1) vector if
* SIDE = 'R'.
*
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* w := conjg( C1 + v' * C2 )
+* w := ( C1 + v**H * C2 )**H
*
CALL CCOPY( N, C1, LDC, WORK, 1 )
CALL CLACGV( N, WORK, 1 )
CALL CGEMV( 'Conjugate transpose', M-1, N, ONE, C2, LDC, V,
$ INCV, ONE, WORK, 1 )
*
-* [ C1 ] := [ C1 ] - tau* [ 1 ] * w'
+* [ C1 ] := [ C1 ] - tau* [ 1 ] * w**H
* [ C2 ] [ C2 ] [ v ]
*
CALL CLACGV( N, WORK, 1 )
CALL CGEMV( 'No transpose', M, N-1, ONE, C2, LDC, V, INCV, ONE,
$ WORK, 1 )
*
-* [ C1, C2 ] := [ C1, C2 ] - tau* w * [ 1 , v']
+* [ C1, C2 ] := [ C1, C2 ] - tau* w * [ 1 , v**H]
*
CALL CAXPY( M, -TAU, WORK, 1, C1, 1 )
CALL CGERC( M, N-1, -TAU, WORK, 1, V, INCV, C2, LDC )
* Purpose
* =======
*
-* CLAUU2 computes the product U * U' or L' * L, where the triangular
+* CLAUU2 computes the product U * U**H or L**H * L, where the triangular
* factor U or L is stored in the upper or lower triangular part of
* the array A.
*
* A (input/output) COMPLEX array, dimension (LDA,N)
* On entry, the triangular factor U or L.
* On exit, if UPLO = 'U', the upper triangle of A is
-* overwritten with the upper triangle of the product U * U';
+* overwritten with the upper triangle of the product U * U**H;
* if UPLO = 'L', the lower triangle of A is overwritten with
-* the lower triangle of the product L' * L.
+* the lower triangle of the product L**H * L.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the product U * U'.
+* Compute the product U * U**H.
*
DO 10 I = 1, N
AII = A( I, I )
*
ELSE
*
-* Compute the product L' * L.
+* Compute the product L**H * L.
*
DO 20 I = 1, N
AII = A( I, I )
* Purpose
* =======
*
-* CLAUUM computes the product U * U' or L' * L, where the triangular
+* CLAUUM computes the product U * U**H or L**H * L, where the triangular
* factor U or L is stored in the upper or lower triangular part of
* the array A.
*
* A (input/output) COMPLEX array, dimension (LDA,N)
* On entry, the triangular factor U or L.
* On exit, if UPLO = 'U', the upper triangle of A is
-* overwritten with the upper triangle of the product U * U';
+* overwritten with the upper triangle of the product U * U**H;
* if UPLO = 'L', the lower triangle of A is overwritten with
-* the lower triangle of the product L' * L.
+* the lower triangle of the product L**H * L.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the product U * U'.
+* Compute the product U * U**H.
*
DO 10 I = 1, N, NB
IB = MIN( NB, N-I+1 )
10 CONTINUE
ELSE
*
-* Compute the product L' * L.
+* Compute the product L**H * L.
*
DO 20 I = 1, N, NB
IB = MIN( NB, N-I+1 )
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**H).
*
CALL CLATBS( 'Upper', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, KD, AB, LDAB, WORK, SCALEL, RWORK,
$ KD, AB, LDAB, WORK, SCALEL, RWORK, INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**H).
*
CALL CLATBS( 'Lower', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, KD, AB, LDAB, WORK, SCALEU, RWORK,
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H*U or A = L*L**H.
*
CALL CPBTRF( UPLO, N, KD, AB, LDAB, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H *U or A = L*L**H.
*
IF( UPPER ) THEN
DO 40 J = 1, N
* positive definite band matrix A.
*
* The factorization has the form
-* A = U' * U , if UPLO = 'U', or
-* A = L * L', if UPLO = 'L',
-* where U is an upper triangular matrix, U' is the conjugate transpose
+* A = U**H * U , if UPLO = 'U', or
+* A = L * L**H, if UPLO = 'L',
+* where U is an upper triangular matrix, U**H is the conjugate transpose
* of U, and L is lower triangular.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
*
* On exit, if INFO = 0, the triangular factor U or L from the
-* Cholesky factorization A = U'*U or A = L*L' of the band
+* Cholesky factorization A = U**H *U or A = L*L**H of the band
* matrix A, in the same storage format as A.
*
* LDAB (input) INTEGER
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**H * U.
*
DO 10 J = 1, N
*
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**H.
*
DO 20 J = 1, N
*
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**H *U.
*
DO 10 J = 1, NRHS
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**H *X = B, overwriting B with X.
*
CALL CTBSV( 'Upper', 'Conjugate transpose', 'Non-unit', N,
$ KD, AB, LDAB, B( 1, J ), 1 )
10 CONTINUE
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L*L**H.
*
DO 20 J = 1, NRHS
*
CALL CTBSV( 'Lower', 'No transpose', 'Non-unit', N, KD, AB,
$ LDAB, B( 1, J ), 1 )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**H *X = B, overwriting B with X.
*
CALL CTBSV( 'Lower', 'Conjugate transpose', 'Non-unit', N,
$ KD, AB, LDAB, B( 1, J ), 1 )
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**H).
*
CALL CLATRS( 'Upper', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, A, LDA, WORK, SCALEL, RWORK, INFO )
$ A, LDA, WORK, SCALEL, RWORK, INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**H).
*
CALL CLATRS( 'Lower', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, A, LDA, WORK, SCALEU, RWORK, INFO )
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H*U or A = L*L**H.
*
CALL CPOTRF( UPLO, N, A, LDA, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H *U or A = L*L**H.
*
CALL CLACPY( UPLO, N, N, A, LDA, AF, LDAF )
CALL CPOTRF( UPLO, N, AF, LDAF, INFO )
* positive definite matrix A.
*
* The factorization has the form
-* A = U' * U , if UPLO = 'U', or
-* A = L * L', if UPLO = 'L',
+* A = U**H * U , if UPLO = 'U', or
+* A = L * L**H, if UPLO = 'L',
* where U is an upper triangular matrix and L is lower triangular.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* triangular part of A is not referenced.
*
* On exit, if INFO = 0, the factor U or L from the Cholesky
-* factorization A = U'*U or A = L*L'.
+* factorization A = U**H *U or A = L*L**H.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**H *U.
*
DO 10 J = 1, N
*
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**H.
*
DO 20 J = 1, N
*
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**H *U.
*
DO 10 J = 1, N, NB
*
*
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**H.
*
DO 20 J = 1, N, NB
*
IF( INFO.GT.0 )
$ RETURN
*
-* Form inv(U)*inv(U)' or inv(L)'*inv(L).
+* Form inv(U) * inv(U)**H or inv(L)**H * inv(L).
*
CALL CLAUUM( UPLO, N, A, LDA, INFO )
*
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**H *U.
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**H *X = B, overwriting B with X.
*
CALL CTRSM( 'Left', 'Upper', 'Conjugate transpose', 'Non-unit',
$ N, NRHS, ONE, A, LDA, B, LDB )
$ NRHS, ONE, A, LDA, B, LDB )
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L*L**H.
*
* Solve L*X = B, overwriting B with X.
*
CALL CTRSM( 'Left', 'Lower', 'No transpose', 'Non-unit', N,
$ NRHS, ONE, A, LDA, B, LDB )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**H *X = B, overwriting B with X.
*
CALL CTRSM( 'Left', 'Lower', 'Conjugate transpose', 'Non-unit',
$ N, NRHS, ONE, A, LDA, B, LDB )
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**H).
*
CALL CLATPS( 'Upper', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, AP, WORK, SCALEL, RWORK, INFO )
$ AP, WORK, SCALEL, RWORK, INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**H).
*
CALL CLATPS( 'Lower', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, AP, WORK, SCALEU, RWORK, INFO )
* packed format and X and B are N-by-NRHS matrices.
*
* The Cholesky decomposition is used to factor A as
-* A = U**H* U, if UPLO = 'U', or
+* A = U**H * U, if UPLO = 'U', or
* A = L * L**H, if UPLO = 'L',
* where U is an upper triangular matrix and L is a lower triangular
* matrix. The factored form of A is then used to solve the system of
* is stored in the array AP as follows:
* if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
* if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
-* See below for further details.
+* See below for further details.
*
* On exit, if INFO = 0, the factor U or L from the Cholesky
* factorization A = U**H*U or A = L*L**H, in the same storage
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H *U or A = L*L**H.
*
CALL CPPTRF( UPLO, N, AP, INFO )
IF( INFO.EQ.0 ) THEN
*
* 2. If FACT = 'N' or 'E', the Cholesky decomposition is used to
* factor the matrix A (after equilibration if FACT = 'E') as
-* A = U'* U , if UPLO = 'U', or
-* A = L * L', if UPLO = 'L',
+* 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.
*
*
* If FACT = 'N', then AFP is an output argument and on exit
* returns the triangular factor U or L from the Cholesky
-* factorization A = U**H*U or A = L*L**H of the original
+* factorization A = U**H * U or A = L * L**H of the original
* matrix A.
*
* If FACT = 'E', then AFP is an output argument and on exit
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H * U or A = L * L**H.
*
CALL CCOPY( N*( N+1 ) / 2, AP, 1, AFP, 1 )
CALL CPPTRF( UPLO, N, AFP, INFO )
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**H * U.
*
JJ = 0
DO 10 J = 1, N
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L * L**H.
*
JJ = 1
DO 20 J = 1, N
$ RETURN
IF( UPPER ) THEN
*
-* Compute the product inv(U) * inv(U)'.
+* Compute the product inv(U) * inv(U)**H.
*
JJ = 0
DO 10 J = 1, N
*
ELSE
*
-* Compute the product inv(L)' * inv(L).
+* Compute the product inv(L)**H * inv(L).
*
JJ = 1
DO 20 J = 1, N
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**H * U.
*
DO 10 I = 1, NRHS
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**H *X = B, overwriting B with X.
*
CALL CTPSV( 'Upper', 'Conjugate transpose', 'Non-unit', N,
$ AP, B( 1, I ), 1 )
10 CONTINUE
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L * L**H.
*
DO 20 I = 1, NRHS
*
CALL CTPSV( 'Lower', 'No transpose', 'Non-unit', N, AP,
$ B( 1, I ), 1 )
*
-* Solve L'*X = Y, overwriting B with X.
+* Solve L**H *X = Y, overwriting B with X.
*
CALL CTPSV( 'Lower', 'Conjugate transpose', 'Non-unit', N,
$ AP, B( 1, I ), 1 )
* 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)'.
+* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**H.
*
* Solve M(L) * x = e.
*
RWORK( I ) = ONE + RWORK( I-1 )*ABS( E( I-1 ) )
20 CONTINUE
*
-* Solve D * M(L)' * x = b.
+* Solve D * M(L)**H * x = b.
*
RWORK( N ) = RWORK( N ) / D( N )
DO 30 I = N - 1, 1, -1
* 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)'.
+* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**H.
*
* Solve M(L) * x = e.
*
RWORK( I ) = ONE + RWORK( I-1 )*ABS( EF( I-1 ) )
70 CONTINUE
*
-* Solve D * M(L)' * x = b.
+* Solve D * M(L)**H * x = b.
*
RWORK( N ) = RWORK( N ) / DF( N )
DO 80 I = N - 1, 1, -1
RETURN
END IF
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**H (or U**H*D*U) factorization of A.
*
CALL CPTTRF( N, D, E, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**H (or U**H*D*U) factorization of A.
*
CALL SCOPY( N, D, 1, DF, 1 )
IF( N.GT.1 )
* Purpose
* =======
*
-* CPTTRF computes the L*D*L' factorization of a complex Hermitian
+* CPTTRF computes the L*D*L**H factorization of a complex Hermitian
* positive definite tridiagonal matrix A. The factorization may also
-* be regarded as having the form A = U'*D*U.
+* be regarded as having the form A = U**H *D*U.
*
* Arguments
* =========
* D (input/output) REAL array, dimension (N)
* On entry, the n diagonal elements of the tridiagonal matrix
* A. On exit, the n diagonal elements of the diagonal matrix
-* D from the L*D*L' factorization of A.
+* D from the L*D*L**H factorization of A.
*
* E (input/output) COMPLEX array, dimension (N-1)
* On entry, the (n-1) subdiagonal elements of the tridiagonal
* matrix A. On exit, the (n-1) subdiagonal elements of the
-* unit bidiagonal factor L from the L*D*L' factorization of A.
+* unit bidiagonal factor L from the L*D*L**H factorization of A.
* E can also be regarded as the superdiagonal of the unit
-* bidiagonal factor U from the U'*D*U factorization of A.
+* bidiagonal factor U from the U**H *D*U factorization of A.
*
* INFO (output) INTEGER
* = 0: successful exit
IF( N.EQ.0 )
$ RETURN
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**H (or U**H *D*U) factorization of A.
*
I4 = MOD( N-1, 4 )
DO 10 I = 1, I4
*
* CPTTRS solves a tridiagonal system of the form
* A * X = B
-* using the factorization A = U'*D*U or A = L*D*L' computed by CPTTRF.
+* using the factorization A = U**H*D*U or A = L*D*L**H computed by CPTTRF.
* D is a diagonal matrix specified in the vector D, U (or L) is a unit
* bidiagonal matrix whose superdiagonal (subdiagonal) is specified in
* the vector E, and X and B are N by NRHS matrices.
* Specifies the form of the factorization and whether the
* vector E is the superdiagonal of the upper bidiagonal factor
* U or the subdiagonal of the lower bidiagonal factor L.
-* = 'U': A = U'*D*U, E is the superdiagonal of U
-* = 'L': A = L*D*L', E is the subdiagonal of L
+* = 'U': A = U**H*D*U, E is the superdiagonal of U
+* = 'L': A = L*D*L**H, E is the subdiagonal of L
*
* N (input) INTEGER
* The order of the tridiagonal matrix A. N >= 0.
*
* D (input) REAL array, dimension (N)
* The n diagonal elements of the diagonal matrix D from the
-* factorization A = U'*D*U or A = L*D*L'.
+* factorization A = U**H*D*U or A = L*D*L**H.
*
* E (input) COMPLEX array, dimension (N-1)
* If UPLO = 'U', the (n-1) superdiagonal elements of the unit
-* bidiagonal factor U from the factorization A = U'*D*U.
+* bidiagonal factor U from the factorization A = U**H*D*U.
* If UPLO = 'L', the (n-1) subdiagonal elements of the unit
-* bidiagonal factor L from the factorization A = L*D*L'.
+* bidiagonal factor L from the factorization A = L*D*L**H.
*
* B (input/output) REAL array, dimension (LDB,NRHS)
* On entry, the right hand side vectors B for the system of
*
* CPTTS2 solves a tridiagonal system of the form
* A * X = B
-* using the factorization A = U'*D*U or A = L*D*L' computed by CPTTRF.
+* using the factorization A = U**H*D*U or A = L*D*L**H computed by CPTTRF.
* D is a diagonal matrix specified in the vector D, U (or L) is a unit
* bidiagonal matrix whose superdiagonal (subdiagonal) is specified in
* the vector E, and X and B are N by NRHS matrices.
* Specifies the form of the factorization and whether the
* vector E is the superdiagonal of the upper bidiagonal factor
* U or the subdiagonal of the lower bidiagonal factor L.
-* = 1: A = U'*D*U, E is the superdiagonal of U
-* = 0: A = L*D*L', E is the subdiagonal of L
+* = 1: A = U**H *D*U, E is the superdiagonal of U
+* = 0: A = L*D*L**H, E is the subdiagonal of L
*
* N (input) INTEGER
* The order of the tridiagonal matrix A. N >= 0.
*
* D (input) REAL array, dimension (N)
* The n diagonal elements of the diagonal matrix D from the
-* factorization A = U'*D*U or A = L*D*L'.
+* factorization A = U**H *D*U or A = L*D*L**H.
*
* E (input) COMPLEX array, dimension (N-1)
* If IUPLO = 1, the (n-1) superdiagonal elements of the unit
-* bidiagonal factor U from the factorization A = U'*D*U.
+* bidiagonal factor U from the factorization A = U**H*D*U.
* If IUPLO = 0, the (n-1) subdiagonal elements of the unit
-* bidiagonal factor L from the factorization A = L*D*L'.
+* bidiagonal factor L from the factorization A = L*D*L**H.
*
* B (input/output) REAL array, dimension (LDB,NRHS)
* On entry, the right hand side vectors B for the system of
*
IF( IUPLO.EQ.1 ) THEN
*
-* Solve A * X = B using the factorization A = U'*D*U,
+* Solve A * X = B using the factorization A = U**H *D*U,
* overwriting each right hand side vector with its solution.
*
IF( NRHS.LE.2 ) THEN
J = 1
5 CONTINUE
*
-* Solve U' * x = b.
+* Solve U**H * x = b.
*
DO 10 I = 2, N
B( I, J ) = B( I, J ) - B( I-1, J )*CONJG( E( I-1 ) )
ELSE
DO 60 J = 1, NRHS
*
-* Solve U' * x = b.
+* Solve U**H * x = b.
*
DO 40 I = 2, N
B( I, J ) = B( I, J ) - B( I-1, J )*CONJG( E( I-1 ) )
END IF
ELSE
*
-* Solve A * X = B using the factorization A = L*D*L',
+* Solve A * X = B using the factorization A = L*D*L**H,
* overwriting each right hand side vector with its solution.
*
IF( NRHS.LE.2 ) THEN
B( I, J ) = B( I, J ) - B( I-1, J )*E( I-1 )
70 CONTINUE
*
-* Solve D * L' * x = b.
+* Solve D * L**H * x = b.
*
DO 80 I = 1, N
B( I, J ) = B( I, J ) / D( I )
B( I, J ) = B( I, J ) - B( I-1, J )*E( I-1 )
100 CONTINUE
*
-* Solve D * L' * x = b.
+* Solve D * L**H * x = b.
*
B( N, J ) = B( N, J ) / D( N )
DO 110 I = N - 1, 1, -1
CALL CLACN2( N, WORK( N+1 ), WORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**T) or inv(U*D*U**T).
*
CALL CSPTRS( UPLO, N, 1, AP, IPIV, WORK, N, INFO )
GO TO 30
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL CSPTRF( UPLO, N, AP, IPIV, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL CCOPY( N*( N+1 ) / 2, AP, 1, AFP, 1 )
CALL CSPTRF( UPLO, N, AFP, IPIV, INFO )
* 5-96 - Based on modifications by J. Lewis, Boeing Computer Services
* Company
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**T = A - W(k)*1/D(k)*W(k)**T
*
R1 = CONE / AP( KC+K-1 )
CALL CSPR( UPLO, K-1, -R1, AP( KC ), 1, AP )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**T
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**T
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**T = A - W(k)*(1/D(k))*W(k)**T
*
R1 = CONE / AP( KC )
CALL CSPR( UPLO, N-K, -R1, AP( KC+1 ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )'
-* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )'
+* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )**T
+* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )**T
*
* where L(k) and L(k+1) are the k-th and (k+1)-th
* columns of L
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**T.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**T*X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**T(K)), where U(K) is the transformation
* stored in column K of A.
*
CALL CGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, AP( KC ),
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**T(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
CALL CGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, AP( KC ),
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**T.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**T*X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**T(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N )
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**T(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
CALL CLACN2( N, WORK( N+1 ), WORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**T) or inv(U*D*U**T).
*
CALL CSYTRS( UPLO, N, 1, A, LDA, IPIV, WORK, N, INFO )
GO TO 30
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL CSYTRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL CLACPY( UPLO, N, N, A, LDA, AF, LDAF )
CALL CSYTRF( UPLO, N, AF, LDAF, IPIV, WORK, LWORK, INFO )
* CSYTF2 computes the factorization of a complex symmetric matrix A
* using the Bunch-Kaufman diagonal pivoting method:
*
-* A = U*D*U' or A = L*D*L'
+* A = U*D*U**T or A = L*D*L**T
*
* where U (or L) is a product of permutation and unit upper (lower)
-* triangular matrices, U' is the transpose of U, and D is symmetric and
+* triangular matrices, U**T is the transpose of U, and D is symmetric and
* block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* 1-96 - Based on modifications by J. Lewis, Boeing Computer Services
* Company
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**T = A - W(k)*1/D(k)*W(k)**T
*
R1 = CONE / A( K, K )
CALL CSYR( UPLO, K-1, -R1, A( 1, K ), 1, A, LDA )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**T
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**T
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**T = A - W(k)*(1/D(k))*W(k)**T
*
R1 = CONE / A( K, K )
CALL CSYR( UPLO, N-K, -R1, A( K+1, K ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )'
-* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )'
+* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )**T
+* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )**T
*
* where L(k) and L(k+1) are the k-th and (k+1)-th
* columns of L
* Further Details
* ===============
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* KB, where KB is the number of columns factorized by CLASYF;
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* KB, where KB is the number of columns factorized by CLASYF;
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
IF( UPPER ) THEN
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
*
CALL CTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**T) = (inv(U))**T
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**T)*inv(D)*inv(U)
*
CUT=N
DO WHILE (CUT .GT. 0)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
*
CALL CTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**T) = (inv(U))**T
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**T)*inv(D)*inv(U)
*
CUT=0
DO WHILE (CUT .LT. N)
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
*
I=N
DO WHILE ( I .GE. 1 )
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**T.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**T *X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**T(K)), where U(K) is the transformation
* stored in column K of A.
*
CALL CGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, A( 1, K ),
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**T(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
CALL CGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, A( 1, K ),
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**T.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**T *X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**T(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N )
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**T(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* 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
END IF
END DO
*
-* Compute (U \P' * B) -> B [ (U \P' * B) ]
+* Compute (U \P**T * B) -> B [ (U \P**T * B) ]
*
CALL CTRSM('L','U','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (U \P' * B) ]
+* Compute D \ B -> B [ D \ (U \P**T * B) ]
*
I=N
DO WHILE ( I .GE. 1 )
I = I - 1
END DO
*
-* Compute (U' \ B) -> B [ U' \ (D \ (U \P' * B) ) ]
+* Compute (U**T \ B) -> B [ U**T \ (D \ (U \P**T * B) ) ]
*
CALL CTRSM('L','U','T','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (U' \ (D \ (U \P' * B) )) ]
+* P * B [ P * (U**T \ (D \ (U \P**T * B) )) ]
*
K=1
DO WHILE ( K .LE. N )
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* 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
ENDIF
END DO
*
-* Compute (L \P' * B) -> B [ (L \P' * B) ]
+* Compute (L \P**T * B) -> B [ (L \P**T * B) ]
*
CALL CTRSM('L','L','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (L \P' * B) ]
+* Compute D \ B -> B [ D \ (L \P**T * B) ]
*
I=1
DO WHILE ( I .LE. N )
I = I + 1
END DO
*
-* Compute (L' \ B) -> B [ L' \ (D \ (L \P' * B) ) ]
+* Compute (L**T \ B) -> B [ L**T \ (D \ (L \P**T * B) ) ]
*
CALL CTRSM('L','L','T','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (L' \ (D \ (L \P' * B) )) ]
+* P * B [ P * (L**T \ (D \ (L \P**T * B) )) ]
*
K=N
DO WHILE ( K .GE. 1 )
* Optionally, the matrices Q and Z of generalized Schur vectors are
* updated.
*
-* Q(in) * A(in) * Z(in)' = Q(out) * A(out) * Z(out)'
-* Q(in) * B(in) * Z(in)' = Q(out) * B(out) * Z(out)'
+* Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H
+* Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H
*
*
* Arguments
IF( WANDS ) THEN
*
* Strong stability test:
-* F-norm((A-QL'*S*QR, B-QL'*T*QR)) <= O(EPS*F-norm((A, B)))
+* F-norm((A-QL**H*S*QR, B-QL**H*T*QR)) <= O(EPS*F-norm((A, B)))
*
CALL CLACPY( 'Full', M, M, S, LDST, WORK, M )
CALL CLACPY( 'Full', M, M, T, LDST, WORK( M*M+1 ), M )
* Optionally, the matrices Q and Z of generalized Schur vectors are
* updated.
*
-* Q(in) * A(in) * Z(in)' = Q(out) * A(out) * Z(out)'
-* Q(in) * B(in) * Z(in)' = Q(out) * B(out) * Z(out)'
+* Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H
+* Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H
*
* Arguments
* =========
*
* CTGSEN reorders the generalized Schur decomposition of a complex
* matrix pair (A, B) (in terms of an unitary equivalence trans-
-* formation Q' * (A, B) * Z), so that a selected cluster of eigenvalues
+* formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues
* appears in the leading diagonal blocks of the pair (A,B). The leading
* columns of Q and Z form unitary bases of the corresponding left and
* right eigenspaces (deflating subspaces). (A, B) must be in
* U and W that move them to the top left corner of (A, B). In other
* words, the selected eigenvalues are the eigenvalues of (A11, B11) in
*
-* U'*(A, B)*W = (A11 A12) (B11 B12) n1
+* U**H*(A, B)*W = (A11 A12) (B11 B12) n1
* ( 0 A22),( 0 B22) n2
* n1 n2 n1 n2
*
-* where N = n1+n2 and U' means the conjugate transpose of U. The first
+* where N = n1+n2 and U**H means the conjugate 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).
*
* decomposition of a matrix pair (C, D) = Q*(A, B)*Z', then the
* reordered generalized Schur form of (C, D) is given by
*
-* (C, D) = (Q*U)*(U'*(A, B)*W)*(Z*W)',
+* (C, D) = (Q*U)*(U**H *(A, B)*W)*(Z*W)**H,
*
* and the first n1 columns of Q*U and Z*W span the corresponding
* deflating subspaces of (C, D) (Q and Z store Q*U and Z*W, resp.).
*
* On exit,
*
-* U'*A*Q = D1*( 0 R ), V'*B*Q = D2*( 0 R ),
+* U**H *A*Q = D1*( 0 R ), V**H *B*Q = D2*( 0 R ),
*
-* where U, V and Q are unitary matrices, Z' denotes the conjugate
-* transpose of Z, R is a nonsingular upper triangular matrix, and D1
+* where U, V and Q are unitary matrices.
+* R is a nonsingular upper triangular matrix, and D1
* and D2 are ``diagonal'' matrices, which are of the following
* structures:
*
* min(L,M-K)-by-L triangular (or trapezoidal) matrix A23 and L-by-L
* matrix B13 to the form:
*
-* U1'*A13*Q1 = C1*R1; V1'*B13*Q1 = S1*R1,
+* U1**H *A13*Q1 = C1*R1; V1**H *B13*Q1 = S1*R1,
*
-* where U1, V1 and Q1 are unitary matrix, and Z' is the conjugate
-* transpose of Z. C1 and S1 are diagonal matrices satisfying
+* where U1, V1 and Q1 are unitary matrix.
+* C1 and S1 are diagonal matrices satisfying
*
* C1**2 + S1**2 = I,
*
CALL CLAGS2( UPPER, A1, A2, A3, B1, B2, B3, CSU, SNU,
$ CSV, SNV, CSQ, SNQ )
*
-* Update (K+I)-th and (K+J)-th rows of matrix A: U'*A
+* Update (K+I)-th and (K+J)-th rows of matrix A: U**H *A
*
IF( K+J.LE.M )
$ CALL CROT( L, A( K+J, N-L+1 ), LDA, A( K+I, N-L+1 ),
$ LDA, CSU, CONJG( SNU ) )
*
-* Update I-th and J-th rows of matrix B: V'*B
+* Update I-th and J-th rows of matrix B: V**H *B
*
CALL CROT( L, B( J, N-L+1 ), LDB, B( I, N-L+1 ), LDB,
$ CSV, CONJG( SNV ) )
* The reciprocal of the condition number of the i-th generalized
* eigenvalue w = (a, b) is defined as
*
-* S(I) = (|v'Au|**2 + |v'Bu|**2)**(1/2) / (norm(u)*norm(v))
+* S(I) = (|v**HAu|**2 + |v**HBu|**2)**(1/2) / (norm(u)*norm(v))
*
* where u and v are the right and left eigenvectors of (A, B)
* corresponding to w; |z| denotes the absolute value of the complex
* number, and norm(u) denotes the 2-norm of the vector u. The pair
-* (a, b) corresponds to an eigenvalue w = a/b (= v'Au/v'Bu) of the
+* (a, b) corresponds to an eigenvalue w = a/b (= v**HAu/v**HBu) of the
* matrix pair (A, B). If both a and b equal zero, then (A,B) is
* singular and S(I) = -1 is returned.
*
* Zl = [ kron(a, In-1) -kron(1, A22) ]
* [ kron(b, In-1) -kron(1, B22) ].
*
-* Here In-1 is the identity matrix of size n-1 and X' is the conjugate
+* Here In-1 is the identity matrix of size n-1 and X**H is the conjugate
* transpose of X. kron(X, Y) is the Kronecker product between the
* matrices X and Y.
*
ELSE
*
* Solve transposed (I, J) - system:
-* A(I, I)' * R(I, J) + D(I, I)' * L(J, J) = C(I, J)
+* A(I, I)**H * R(I, J) + D(I, I)**H * L(J, J) = C(I, J)
* R(I, I) * B(J, J) + L(I, J) * E(J, J) = -F(I, J)
* for I = 1, 2, ..., M, J = N, N - 1, ..., 1
*
* 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 (TRANS = 'C') is used to compute an one-norm-based estimate
* of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D)
ELSE
*
* Solve transposed (I, J)-subsystem
-* A(I, I)' * R(I, J) + D(I, I)' * L(I, J) = C(I, J)
+* A(I, I)**H * R(I, J) + D(I, I)**H * L(I, J) = C(I, J)
* R(I, J) * B(J, J) + L(I, J) * E(J, J) = -F(I, J)
* for I = 1,2,..., P; J = Q, Q-1,..., 1
*
90 CONTINUE
*
* Solve the triangular system:
-* (T(KI+1:N,KI+1:N) - T(KI,KI))'*X = SCALE*WORK.
+* (T(KI+1:N,KI+1:N) - T(KI,KI))**H*X = SCALE*WORK.
*
DO 100 K = KI + 1, N
T( K, K ) = T( K, K ) - T( KI, KI )
* transformation Z to move them to the top left corner of T. In other
* words, the selected eigenvalues are the eigenvalues of T11 in:
*
-* Z'*T*Z = ( T11 T12 ) n1
+* Z**H * T * Z = ( T11 T12 ) n1
* ( 0 T22 ) n2
* n1 n2
*
-* where N = n1+n2 and Z' means the conjugate transpose of Z. The first
+* where N = n1+n2. The first
* n1 columns of Z span the specified invariant subspace of T.
*
* If T has been obtained from the Schur factorization of a matrix
-* A = Q*T*Q', then the reordered Schur factorization of A is given by
-* A = (Q*Z)*(Z'*T*Z)*(Q*Z)', and the first n1 columns of Q*Z span the
+* A = Q*T*Q**H, then the reordered Schur factorization of A is given by
+* A = (Q*Z)*(Z**H*T*Z)*(Q*Z)**H, and the first n1 columns of Q*Z span the
* corresponding invariant subspace of A.
*
* The reciprocal condition number of the average of the eigenvalues of
$ IERR )
ELSE
*
-* Solve T11'*R - R*T22' = scale*X.
+* Solve T11**H*R - R*T22**H = scale*X.
*
CALL CTRSYL( 'C', 'C', -1, N1, N2, T, LDT,
$ T( N1+1, N1+1 ), LDT, WORK, N1, SCALE,
* The reciprocal of the condition number of an eigenvalue lambda is
* defined as
*
-* S(lambda) = |v'*u| / (norm(u)*norm(v))
+* S(lambda) = |v**H*u| / (norm(u)*norm(v))
*
* where u and v are the right and left eigenvectors of T corresponding
-* to lambda; v' denotes the conjugate transpose of v, and norm(u)
+* to lambda; v**H denotes the conjugate transpose of v, and norm(u)
* denotes the Euclidean norm. These reciprocal condition numbers always
* lie between zero (very badly conditioned) and one (very well
* conditioned). If n = 1, S(lambda) is defined to be 1.
WORK( I, I ) = WORK( I, I ) - WORK( 1, 1 )
20 CONTINUE
*
-* Estimate a lower bound for the 1-norm of inv(C'). The 1st
+* Estimate a lower bound for the 1-norm of inv(C**H). The 1st
* and (N+1)th columns of WORK are used to store work vectors.
*
SEP( KS ) = ZERO
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Solve C'*x = scale*b
+* Solve C**H*x = scale*b
*
CALL CLATRS( 'Upper', 'Conjugate transpose',
$ 'Nonunit', NORMIN, N-1, WORK( 2, 2 ),
*
ELSE IF( .NOT.NOTRNA .AND. NOTRNB ) THEN
*
-* Solve A' *X + ISGN*X*B = scale*C.
+* Solve A**H *X + ISGN*X*B = scale*C.
*
* The (K,L)th block of X is determined starting from
* upper-left corner column by column by
*
-* A'(K,K)*X(K,L) + ISGN*X(K,L)*B(L,L) = C(K,L) - R(K,L)
+* A**H(K,K)*X(K,L) + ISGN*X(K,L)*B(L,L) = C(K,L) - R(K,L)
*
* Where
-* K-1 L-1
-* R(K,L) = SUM [A'(I,K)*X(I,L)] + ISGN*SUM [X(K,J)*B(J,L)]
-* I=1 J=1
+* K-1 L-1
+* R(K,L) = SUM [A**H(I,K)*X(I,L)] + ISGN*SUM [X(K,J)*B(J,L)]
+* I=1 J=1
*
DO 60 L = 1, N
DO 50 K = 1, M
*
ELSE IF( .NOT.NOTRNA .AND. .NOT.NOTRNB ) THEN
*
-* Solve A'*X + ISGN*X*B' = C.
+* Solve A**H*X + ISGN*X*B**H = C.
*
* The (K,L)th block of X is determined starting from
* upper-right corner column by column by
*
-* A'(K,K)*X(K,L) + ISGN*X(K,L)*B'(L,L) = C(K,L) - R(K,L)
+* A**H(K,K)*X(K,L) + ISGN*X(K,L)*B**H(L,L) = C(K,L) - R(K,L)
*
* Where
* K-1
-* R(K,L) = SUM [A'(I,K)*X(I,L)] +
+* R(K,L) = SUM [A**H(I,K)*X(I,L)] +
* I=1
* N
-* ISGN*SUM [X(K,J)*B'(L,J)].
+* ISGN*SUM [X(K,J)*B**H(L,J)].
* J=L+1
*
DO 90 L = N, 1, -1
*
ELSE IF( NOTRNA .AND. .NOT.NOTRNB ) THEN
*
-* Solve A*X + ISGN*X*B' = C.
+* Solve A*X + ISGN*X*B**H = C.
*
* The (K,L)th block of X is determined starting from
* bottom-left corner column by column by
*
-* A(K,K)*X(K,L) + ISGN*X(K,L)*B'(L,L) = C(K,L) - R(K,L)
+* A(K,K)*X(K,L) + ISGN*X(K,L)*B**H(L,L) = C(K,L) - R(K,L)
*
* Where
* M N
-* R(K,L) = SUM [A(K,I)*X(I,L)] + ISGN*SUM [X(K,J)*B'(L,J)]
+* R(K,L) = SUM [A(K,I)*X(I,L)] + ISGN*SUM [X(K,J)*B**H(L,J)]
* I=K+1 J=L+1
*
DO 120 L = N, 1, -1
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
-* ( 0 )
-* ( z( k ) )
+* T( k ) = I - tau*u( k )*u( k )**H, u( k ) = ( 1 ),
+* ( 0 )
+* ( z( k ) )
*
* tau is a scalar and z( k ) is an ( n - m ) element vector.
* tau and z( k ) are chosen to annihilate the elements of the kth row
*
IF( TAU( K ).NE.CZERO .AND. K.GT.1 ) THEN
*
-* We now perform the operation A := A*P( k )'.
+* We now perform the operation A := A*P( k )**H.
*
* Use the first ( k - 1 ) elements of TAU to store a( k ),
* where a( k ) consists of the first ( k - 1 ) elements of
$ LDA, A( K, M1 ), LDA, CONE, TAU, 1 )
*
* Now form a( k ) := a( k ) - conjg(tau)*w
-* and B := B - conjg(tau)*w*z( k )'.
+* and B := B - conjg(tau)*w*z( k )**H.
*
CALL CAXPY( K-1, -CONJG( TAU( K ) ), TAU, 1, A( 1, K ),
$ 1 )
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
+* T( k ) = I - tau*u( k )*u( k )**H, u( k ) = ( 1 ),
* ( 0 )
* ( z( k ) )
*
* which is defined as the first m rows of a product of k elementary
* reflectors of order n
*
-* Q = H(k)' . . . H(2)' H(1)'
+* Q = H(k)**H . . . H(2)**H H(1)**H
*
* as returned by CGELQF.
*
*
DO 40 I = K, 1, -1
*
-* Apply H(i)' to A(i:m,i:n) from the right
+* Apply H(i)**H to A(i:m,i:n) from the right
*
IF( I.LT.N ) THEN
CALL CLACGV( N-I, A( I, I+1 ), LDA )
* which is defined as the first M rows of a product of K elementary
* reflectors of order N
*
-* Q = H(k)' . . . H(2)' H(1)'
+* Q = H(k)**H . . . H(2)**H H(1)**H
*
* as returned by CGELQF.
*
CALL CLARFT( 'Forward', 'Rowwise', N-I+1, IB, A( I, I ),
$ LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i+ib:m,i:n) from the right
+* Apply H**H to A(i+ib:m,i:n) from the right
*
CALL CLARFB( 'Right', 'Conjugate transpose', 'Forward',
$ 'Rowwise', M-I-IB+1, N-I+1, IB, A( I, I ),
$ WORK( IB+1 ), LDWORK )
END IF
*
-* Apply H' to columns i:n of current block
+* Apply H**H to columns i:n of current block
*
CALL CUNGL2( IB, N-I+1, IB, A( I, I ), LDA, TAU( I ), WORK,
$ IINFO )
* which is defined as the last m rows of a product of k elementary
* reflectors of order n
*
-* Q = H(1)' H(2)' . . . H(k)'
+* Q = H(1)**H H(2)**H . . . H(k)**H
*
* as returned by CGERQF.
*
DO 40 I = 1, K
II = M - K + I
*
-* Apply H(i)' to A(1:m-k+i,1:n-k+i) from the right
+* Apply H(i)**H to A(1:m-k+i,1:n-k+i) from the right
*
CALL CLACGV( N-M+II-1, A( II, 1 ), LDA )
A( II, N-M+II ) = ONE
* which is defined as the last M rows of a product of K elementary
* reflectors of order N
*
-* Q = H(1)' H(2)' . . . H(k)'
+* Q = H(1)**H H(2)**H . . . H(k)**H
*
* as returned by CGERQF.
*
CALL CLARFT( 'Backward', 'Rowwise', N-K+I+IB-1, IB,
$ A( II, 1 ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(1:m-k+i-1,1:n-k+i+ib-1) from the right
+* Apply H**H to A(1:m-k+i-1,1:n-k+i+ib-1) from the right
*
CALL CLARFB( 'Right', 'Conjugate transpose', 'Backward',
$ 'Rowwise', II-1, N-K+I+IB-1, IB, A( II, 1 ),
$ LDWORK )
END IF
*
-* Apply H' to columns 1:n-k+i+ib-1 of current block
+* Apply H**H to columns 1:n-k+i+ib-1 of current block
*
CALL CUNGR2( IB, N-K+I+IB-1, IB, A( II, 1 ), LDA, TAU( I ),
$ WORK, IINFO )
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'C', or
+* Q**H* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'C',
+* C * Q**H if SIDE = 'R' and TRANS = 'C',
*
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**H from the Left
+* = 'R': apply Q or Q**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'C': apply Q' (Conjugate transpose)
+* = 'C': apply Q**H (Conjugate transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) COMPLEX array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(1:m-k+i,1:n)
+* H(i) or H(i)**H is applied to C(1:m-k+i,1:n)
*
MI = M - K + I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,1:n-k+i)
+* H(i) or H(i)**H is applied to C(1:m,1:n-k+i)
*
NI = N - K + I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = TAU( I )
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'C', or
+* Q**H* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'C',
+* C * Q**H if SIDE = 'R' and TRANS = 'C',
*
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**H from the Left
+* = 'R': apply Q or Q**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'C': apply Q' (Conjugate transpose)
+* = 'C': apply Q**H (Conjugate transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) COMPLEX array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(i:m,1:n)
+* H(i) or H(i)**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,i:n)
+* H(i) or H(i)**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = TAU( I )
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'C', or
+* Q**H* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'C',
+* C * Q**H if SIDE = 'R' and TRANS = 'C',
*
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
*
-* Q = H(k)' . . . H(2)' H(1)'
+* Q = H(k)**H . . . H(2)**H H(1)**H
*
* as returned by CGELQF. Q is of order m if SIDE = 'L' and of order n
* if SIDE = 'R'.
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**H from the Left
+* = 'R': apply Q or Q**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'C': apply Q' (Conjugate transpose)
+* = 'C': apply Q**H (Conjugate transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) COMPLEX array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(i:m,1:n)
+* H(i) or H(i)**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,i:n)
+* H(i) or H(i)**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = CONJG( TAU( I ) )
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
*
-* Q = H(k)' . . . H(2)' H(1)'
+* Q = H(k)**H . . . H(2)**H H(1)**H
*
* as returned by CGELQF. Q is of order M if SIDE = 'L' and of order N
* if SIDE = 'R'.
$ LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**H
*
CALL CLARFB( SIDE, TRANST, 'Forward', 'Rowwise', MI, NI, IB,
$ A( I, I ), LDA, T, LDT, C( IC, JC ), LDC, WORK,
$ A( 1, I ), LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(1:m-k+i+ib-1,1:n)
+* H or H**H is applied to C(1:m-k+i+ib-1,1:n)
*
MI = M - K + I + IB - 1
ELSE
*
-* H or H' is applied to C(1:m,1:n-k+i+ib-1)
+* H or H**H is applied to C(1:m,1:n-k+i+ib-1)
*
NI = N - K + I + IB - 1
END IF
*
-* Apply H or H'
+* Apply H or H**H
*
CALL CLARFB( SIDE, TRANS, 'Backward', 'Columnwise', MI, NI,
$ IB, A( 1, I ), LDA, T, LDT, C, LDC, WORK,
$ LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**H
*
CALL CLARFB( SIDE, TRANS, 'Forward', 'Columnwise', MI, NI,
$ IB, A( I, I ), LDA, T, LDT, C( IC, JC ), LDC,
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'C', or
+* Q**H* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'C',
+* C * Q**H if SIDE = 'R' and TRANS = 'C',
*
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
*
-* Q = H(1)' H(2)' . . . H(k)'
+* Q = H(1)**H H(2)**H . . . H(k)**H
*
* as returned by CGERQF. Q is of order m if SIDE = 'L' and of order n
* if SIDE = 'R'.
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**H from the Left
+* = 'R': apply Q or Q**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'C': apply Q' (Conjugate transpose)
+* = 'C': apply Q**H (Conjugate transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) COMPLEX array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(1:m-k+i,1:n)
+* H(i) or H(i)**H is applied to C(1:m-k+i,1:n)
*
MI = M - K + I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,1:n-k+i)
+* H(i) or H(i)**H is applied to C(1:m,1:n-k+i)
*
NI = N - K + I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = CONJG( TAU( I ) )
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'C', or
+* Q**H* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'C',
+* C * Q**H if SIDE = 'R' and TRANS = 'C',
*
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**H from the Left
+* = 'R': apply Q or Q**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'C': apply Q' (Conjugate transpose)
+* = 'C': apply Q**H (Conjugate transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) COMPLEX array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(i:m,1:n)
+* H(i) or H(i)**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,i:n)
+* H(i) or H(i)**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = TAU( I )
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
*
-* Q = H(1)' H(2)' . . . H(k)'
+* Q = H(1)**H H(2)**H . . . H(k)**H
*
* as returned by CGERQF. Q is of order M if SIDE = 'L' and of order N
* if SIDE = 'R'.
$ A( I, 1 ), LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(1:m-k+i+ib-1,1:n)
+* H or H**H is applied to C(1:m-k+i+ib-1,1:n)
*
MI = M - K + I + IB - 1
ELSE
*
-* H or H' is applied to C(1:m,1:n-k+i+ib-1)
+* H or H**H is applied to C(1:m,1:n-k+i+ib-1)
*
NI = N - K + I + IB - 1
END IF
*
-* Apply H or H'
+* Apply H or H**H
*
CALL CLARFB( SIDE, TRANST, 'Backward', 'Rowwise', MI, NI,
$ IB, A( I, 1 ), LDA, T, LDT, C, LDC, WORK,
*
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**H
*
CALL CLARZB( SIDE, TRANST, 'Backward', 'Rowwise', MI, NI,
$ IB, L, A( I, JA ), LDA, T, LDT, C( IC, JC ),
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(1:i,1:n)
+* H(i) or H(i)**H is applied to C(1:i,1:n)
*
MI = I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,1:i)
+* H(i) or H(i)**H is applied to C(1:m,1:i)
*
NI = I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = TAU( I )
AP( II ) = ONE
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(i+1:m,1:n)
+* H(i) or H(i)**H is applied to C(i+1:m,1:n)
*
MI = M - I
IC = I + 1
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,i+1:n)
+* H(i) or H(i)**H is applied to C(1:m,i+1:n)
*
NI = N - I
JC = I + 1
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = TAU( I )
* =======
*
* DGBBRD reduces a real general m-by-n band matrix A to upper
-* bidiagonal form B by an orthogonal transformation: Q' * A * P = B.
+* bidiagonal form B by an orthogonal transformation: Q**T * A * P = B.
*
-* The routine computes B, and optionally forms Q or P', or computes
-* Q'*C for a given matrix C.
+* The routine computes B, and optionally forms Q or P**T, or computes
+* Q**T*C for a given matrix C.
*
* Arguments
* =========
*
* VECT (input) CHARACTER*1
-* Specifies whether or not the matrices Q and P' are to be
+* Specifies whether or not the matrices Q and P**T are to be
* formed.
-* = 'N': do not form Q or P';
+* = 'N': do not form Q or P**T;
* = 'Q': form Q only;
-* = 'P': form P' only;
+* = 'P': form P**T only;
* = 'B': form both.
*
* M (input) INTEGER
*
* C (input/output) DOUBLE PRECISION array, dimension (LDC,NCC)
* On entry, an m-by-ncc matrix C.
-* On exit, C is overwritten by Q'*C.
+* On exit, C is overwritten by Q**T*C.
* C is not referenced if NCC = 0.
*
* LDC (input) INTEGER
RETURN
END IF
*
-* Initialize Q and P' to the unit matrix, if needed
+* Initialize Q and P**T to the unit matrix, if needed
*
IF( WANTQ )
$ CALL DLASET( 'Full', M, M, ZERO, ONE, Q, LDQ )
*
IF( WANTPT ) THEN
*
-* accumulate product of plane rotations in P'
+* accumulate product of plane rotations in P**T
*
DO 60 J = J1, J2, KB1
CALL DROT( N, PT( J+KUN-1, 1 ), LDPT,
$ INFO )
ELSE
*
-* Multiply by inv(U').
+* Multiply by inv(U**T).
*
CALL DLATBS( 'Upper', 'Transpose', 'Non-unit', NORMIN, N,
$ KL+KU, AB, LDAB, WORK, SCALE, WORK( 2*N+1 ),
$ INFO )
*
-* Multiply by inv(L').
+* Multiply by inv(L**T).
*
IF( LNOTI ) THEN
DO 30 J = N - 1, 1, -1
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**T and G(i) = I - taup * u * u**T
*
* where tauq and taup are real scalars, and v and u are real vectors;
* v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in A(i+1:m,i);
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**T and G(i) = I - taup * u * u**T
*
* where tauq and taup are real scalars, and v and u are real vectors;
* v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in A(i+2:m,i);
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**T and G(i) = I - taup * u * u**T
*
* where tauq and taup are real scalars, and v and u are real vectors;
* v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in A(i+1:m,i);
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**T and G(i) = I - taup * u * u**T
*
* where tauq and taup are real scalars, and v and u are real vectors;
* v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in A(i+2:m,i);
$ WORK( LDWRKX*NB+1 ), LDWRKY )
*
* Update the trailing submatrix A(i+nb:m,i+nb:n), using an update
-* of the form A := A - V*Y' - X*U'
+* of the form A := A - V*Y**T - X*U**T
*
CALL DGEMM( 'No transpose', 'Transpose', M-I-NB+1, N-I-NB+1,
$ NB, -ONE, A( I+NB, I ), LDA,
$ A, LDA, WORK, SU, WORK( 3*N+1 ), INFO )
ELSE
*
-* Multiply by inv(U').
+* Multiply by inv(U**T).
*
CALL DLATRS( 'Upper', 'Transpose', 'Non-unit', NORMIN, N, A,
$ LDA, WORK, SU, WORK( 3*N+1 ), INFO )
*
-* Multiply by inv(L').
+* Multiply by inv(L**T).
*
CALL DLATRS( 'Lower', 'Transpose', 'Unit', NORMIN, N, A,
$ LDA, WORK, SL, WORK( 2*N+1 ), INFO )
* A * v(j) = lambda(j) * v(j)
* where lambda(j) is its eigenvalue.
* The left eigenvector u(j) of A satisfies
-* u(j)**H * A = lambda(j) * u(j)**H
-* where u(j)**H denotes the conjugate transpose of u(j).
+* u(j)**T * A = lambda(j) * u(j)**T
+* where u(j)**T denotes the transpose of u(j).
*
* The computed eigenvectors are normalized to have Euclidean norm
* equal to 1 and largest component real.
* A * v(j) = lambda(j) * v(j)
* where lambda(j) is its eigenvalue.
* The left eigenvector u(j) of A satisfies
-* u(j)**H * A = lambda(j) * u(j)**H
-* where u(j)**H denotes the conjugate transpose of u(j).
+* u(j)**T * A = lambda(j) * u(j)**T
+* where u(j)**T denotes the transpose of u(j).
*
* The computed eigenvectors are normalized to have Euclidean norm
* equal to 1 and largest component real.
* =======
*
* DGEHD2 reduces a real general matrix A to upper Hessenberg form H by
-* an orthogonal similarity transformation: Q' * A * Q = H .
+* an orthogonal similarity transformation: Q**T * A * Q = H .
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on
* =======
*
* DGEHRD reduces a real general matrix A to upper Hessenberg form H by
-* an orthogonal similarity transformation: Q' * A * Q = H .
+* an orthogonal similarity transformation: Q**T * A * Q = H .
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on
IB = MIN( NB, IHI-I )
*
* Reduce columns i:i+ib-1 to Hessenberg form, returning the
-* matrices V and T of the block reflector H = I - V*T*V'
+* matrices V and T of the block reflector H = I - V*T*V**T
* which performs the reduction, and also the matrix Y = A*V*T
*
CALL DLAHR2( IHI, I, IB, A( 1, I ), LDA, TAU( I ), T, LDT,
$ WORK, LDWORK )
*
* Apply the block reflector H to A(1:ihi,i+ib:ihi) from the
-* right, computing A := A - Y * V'. V(i+ib,ib-1) must be set
+* right, computing A := A - Y * V**T. V(i+ib,ib-1) must be set
* to 1
*
EI = A( I+IB, I+IB-1 )
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i,i+1:n),
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i,i+1:n),
*
* Least-Squares Problem min || A * X - B ||
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**T * B(1:M,1:NRHS)
*
CALL DORMQR( 'Left', 'Transpose', M, NRHS, N, A, LDA,
$ WORK( 1 ), B, LDB, WORK( MN+1 ), LWORK-MN,
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Q(1:N,:)' * B(1:M,1:NRHS)
+* B(1:N,1:NRHS) := Q(1:N,:)**T * B(1:M,1:NRHS)
*
CALL DORMLQ( 'Left', 'Transpose', N, NRHS, M, A, LDA,
$ WORK( 1 ), B, LDB, WORK( MN+1 ), LWORK-MN,
* 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**T [ inv(T11)*Q1**T*B ]
+* [ 0 ]
* where Q1 consists of the first RANK columns of Q.
*
* Arguments
*
* Details of Householder rotations stored in WORK(MN+1:2*MN)
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**T * B(1:M,1:NRHS)
*
CALL DORM2R( 'Left', 'Transpose', M, NRHS, MN, A, LDA, WORK( 1 ),
$ B, LDB, WORK( 2*MN+1 ), INFO )
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Y' * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := Y**T * B(1:N,1:NRHS)
*
IF( RANK.LT.N ) THEN
DO 50 I = 1, RANK
* 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**T [ inv(T11)*Q1**T*B ]
+* [ 0 ]
* where Q1 consists of the first RANK columns of Q.
*
* This routine is basically identical to the original xGELSX except
* workspace: 2*MN.
* Details of Householder rotations stored in WORK(MN+1:2*MN)
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**T * B(1:M,1:NRHS)
*
CALL DORMQR( 'Left', 'Transpose', M, NRHS, MN, A, LDA, WORK( 1 ),
$ B, LDB, WORK( 2*MN+1 ), LWORK-2*MN, INFO )
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Y' * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := Y**T * B(1:N,1:NRHS)
*
IF( RANK.LT.N ) THEN
CALL DORMRZ( 'Left', 'Transpose', N, NRHS, RANK, N-RANK, A,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in
CALL DLARFT( 'Backward', 'Columnwise', M-K+I+IB-1, IB,
$ A( 1, N-K+I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(1:m-k+i+ib-1,1:n-k+i-1) from the left
+* Apply H**T to A(1:m-k+i+ib-1,1:n-k+i-1) from the left
*
CALL DLARFB( 'Left', 'Transpose', 'Backward',
$ 'Columnwise', M-K+I+IB-1, N-K+I-1, IB,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real/complex scalar, and v is a real/complex vector
* with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in
*
* Each H(i) has the form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
CALL DLARFT( 'Forward', 'Columnwise', M-I+1, IB,
$ A( I, I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i:m,i+ib:n) from the left
+* Apply H**T to A(i:m,i+ib:n) from the left
*
CALL DLARFB( 'Left', 'Transpose', 'Forward',
$ 'Columnwise', M-I+1, N-I-IB+1, IB,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
CALL DLARFT( 'Forward', 'Columnwise', M-I+1, IB,
$ A( I, I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i:m,i+ib:n) from the left
+* Apply H**T to A(i:m,i+ib:n) from the left
*
CALL DLARFB( 'Left', 'Transpose', 'Forward',
$ 'Columnwise', M-I+1, N-I-IB+1, IB,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in
* =======
*
* DGETRS solves a system of linear equations
-* A * X = B or A' * X = B
+* A * X = B or A**T * X = B
* with a general N-by-N matrix A using the LU factorization computed
* by DGETRF.
*
* 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.
$ NRHS, ONE, A, LDA, B, LDB )
ELSE
*
-* Solve A' * X = B.
+* Solve A**T * X = B.
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**T *X = B, overwriting B with X.
*
CALL DTRSM( 'Left', 'Upper', 'Transpose', 'Non-unit', N, NRHS,
$ ONE, A, LDA, B, LDB )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**T *X = B, overwriting B with X.
*
CALL DTRSM( 'Left', 'Lower', 'Transpose', 'Unit', N, NRHS, ONE,
$ A, LDA, B, LDB )
*
* Compute the GQR factorization of matrices A and B:
*
-* Q'*A = ( R11 ) M, Q'*B*Z' = ( T11 T12 ) M
-* ( 0 ) N-M ( 0 T22 ) N-M
-* M M+P-N N-M
+* Q**T*A = ( R11 ) M, Q**T*B*Z**T = ( T11 T12 ) M
+* ( 0 ) N-M ( 0 T22 ) N-M
+* M M+P-N N-M
*
* where R11 and T22 are upper triangular, and Q and Z are
* orthogonal.
$ WORK( M+NP+1 ), LWORK-M-NP, INFO )
LOPT = WORK( M+NP+1 )
*
-* Update left-hand-side vector d = Q'*d = ( d1 ) M
-* ( d2 ) N-M
+* Update left-hand-side vector d = Q**T*d = ( d1 ) M
+* ( d2 ) N-M
*
CALL DORMQR( 'Left', 'Transpose', N, 1, M, A, LDA, WORK, D,
$ MAX( 1, N ), WORK( M+NP+1 ), LWORK-M-NP, INFO )
CALL DCOPY( M, D, 1, X, 1 )
END IF
*
-* Backward transformation y = Z'*y
+* Backward transformation y = Z**T *y
*
CALL DORMRQ( 'Left', 'Transpose', P, 1, NP,
$ B( MAX( 1, N-P+1 ), 1 ), LDB, WORK( M+1 ), Y,
*
* Compute the GRQ factorization of matrices B and A:
*
-* B*Q' = ( 0 T12 ) P Z'*A*Q' = ( R11 R12 ) N-P
-* N-P P ( 0 R22 ) M+P-N
-* N-P P
+* B*Q**T = ( 0 T12 ) P Z**T*A*Q**T = ( R11 R12 ) N-P
+* N-P P ( 0 R22 ) M+P-N
+* N-P P
*
* where T12 and R11 are upper triangular, and Q and Z are
* orthogonal.
$ WORK( P+MN+1 ), LWORK-P-MN, INFO )
LOPT = WORK( P+MN+1 )
*
-* Update c = Z'*c = ( c1 ) N-P
-* ( c2 ) M+P-N
+* Update c = Z**T *c = ( c1 ) N-P
+* ( c2 ) M+P-N
*
CALL DORMQR( 'Left', 'Transpose', M, 1, MN, A, LDA, WORK( P+1 ),
$ C, MAX( 1, M ), WORK( P+MN+1 ), LWORK-P-MN, INFO )
CALL DAXPY( NR, -ONE, D, 1, C( N-P+1 ), 1 )
END IF
*
-* Backward transformation x = Q'*x
+* Backward transformation x = Q**T*x
*
CALL DORMRQ( 'Left', 'Transpose', N, 1, P, B, LDB, WORK( 1 ), X,
$ N, WORK( P+MN+1 ), LWORK-P-MN, INFO )
* In particular, if B is square and nonsingular, the GQR factorization
* of A and B implicitly gives the QR factorization of inv(B)*A:
*
-* inv(B)*A = Z'*(inv(T)*R)
+* inv(B)*A = Z**T*(inv(T)*R)
*
-* where inv(B) denotes the inverse of the matrix B, and Z' denotes the
+* where inv(B) denotes the inverse of the matrix B, and Z**T denotes the
* transpose of the matrix Z.
*
* Arguments
*
* Each H(i) has the form
*
-* H(i) = I - taua * v * v'
+* H(i) = I - taua * v * v**T
*
* where taua is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i+1:n,i),
*
* Each H(i) has the form
*
-* H(i) = I - taub * v * v'
+* H(i) = I - taub * v * v**T
*
* where taub is a real scalar, and v is a real vector with
* v(p-k+i+1:p) = 0 and v(p-k+i) = 1; v(1:p-k+i-1) is stored on exit in
CALL DGEQRF( N, M, A, LDA, TAUA, WORK, LWORK, INFO )
LOPT = WORK( 1 )
*
-* Update B := Q'*B.
+* Update B := Q**T*B.
*
CALL DORMQR( 'Left', 'Transpose', N, P, MIN( N, M ), A, LDA, TAUA,
$ B, LDB, WORK, LWORK, INFO )
* In particular, if B is square and nonsingular, the GRQ factorization
* of A and B implicitly gives the RQ factorization of A*inv(B):
*
-* A*inv(B) = (R*inv(T))*Z'
+* A*inv(B) = (R*inv(T))*Z**T
*
-* where inv(B) denotes the inverse of the matrix B, and Z' denotes the
+* where inv(B) denotes the inverse of the matrix B, and Z**T denotes the
* transpose of the matrix Z.
*
* Arguments
*
* Each H(i) has the form
*
-* H(i) = I - taua * v * v'
+* H(i) = I - taua * v * v**T
*
* where taua is a real scalar, and v is a real vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - taub * v * v'
+* H(i) = I - taub * v * v**T
*
* where taub is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:p) is stored on exit in B(i+1:p,i),
CALL DGERQF( M, N, A, LDA, TAUA, WORK, LWORK, INFO )
LOPT = WORK( 1 )
*
-* Update B := B*Q'
+* Update B := B*Q**T
*
CALL DORMRQ( 'Right', 'Transpose', P, N, MIN( M, N ),
$ A( MAX( 1, M-N+1 ), 1 ), LDA, TAUA, B, LDB, WORK,
* DGGSVD computes the generalized singular value decomposition (GSVD)
* of an M-by-N real matrix A and P-by-N real matrix B:
*
-* U'*A*Q = D1*( 0 R ), V'*B*Q = D2*( 0 R )
+* U**T*A*Q = D1*( 0 R ), V**T*B*Q = D2*( 0 R )
*
-* where U, V and Q are orthogonal matrices, and Z' is the transpose
-* of Z. Let K+L = the effective numerical rank of the matrix (A',B')',
+* where U, V and Q are orthogonal matrices.
+* Let K+L = the effective numerical rank of the matrix (A**T,B**T)**T,
* then R is a K+L-by-K+L nonsingular upper triangular matrix, D1 and
* D2 are M-by-(K+L) and P-by-(K+L) "diagonal" matrices and of the
* following structures, respectively:
*
* In particular, if B is an N-by-N nonsingular matrix, then the GSVD of
* A and B implicitly gives the SVD of A*inv(B):
-* A*inv(B) = U*(D1*inv(D2))*V'.
-* If ( A',B')' has orthonormal columns, then the GSVD of A and B is
+* A*inv(B) = U*(D1*inv(D2))*V**T.
+* If ( A**T,B**T)**T has orthonormal columns, then the GSVD of A and B is
* also equal to the CS decomposition of A and B. Furthermore, the GSVD
* can be used to derive the solution of the eigenvalue problem:
-* A'*A x = lambda* B'*B x.
+* A**T*A x = lambda* B**T*B x.
* In some literature, the GSVD of A and B is presented in the form
-* U'*A*X = ( 0 D1 ), V'*B*X = ( 0 D2 )
+* U**T*A*X = ( 0 D1 ), V**T*B*X = ( 0 D2 )
* where U and V are orthogonal and X is nonsingular, D1 and D2 are
* ``diagonal''. The former GSVD form can be converted to the latter
* form by taking the nonsingular matrix X as
* 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')'.
+* K + L = effective numerical rank of (A',B')**T.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the M-by-N matrix A.
* TOLA DOUBLE PRECISION
* TOLB DOUBLE PRECISION
* TOLA and TOLB are the thresholds to determine the effective
-* rank of (A',B')'. Generally, they are set to
+* rank of (A',B')**T. Generally, they are set to
* TOLA = MAX(M,N)*norm(A)*MAZHEPS,
* TOLB = MAX(P,N)*norm(B)*MAZHEPS.
* The size of TOLA and TOLB may affect the size of backward
*
* DGGSVP computes orthogonal matrices U, V and Q such that
*
-* N-K-L K L
-* U'*A*Q = K ( 0 A12 A13 ) if M-K-L >= 0;
-* L ( 0 0 A23 )
-* M-K-L ( 0 0 0 )
+* N-K-L K L
+* U**T*A*Q = K ( 0 A12 A13 ) if M-K-L >= 0;
+* L ( 0 0 A23 )
+* M-K-L ( 0 0 0 )
*
* N-K-L K L
* = K ( 0 A12 A13 ) if M-K-L < 0;
* M-K ( 0 0 A23 )
*
-* N-K-L K L
-* V'*B*Q = L ( 0 0 B13 )
-* P-L ( 0 0 0 )
+* N-K-L K L
+* V**T*B*Q = L ( 0 0 B13 )
+* P-L ( 0 0 0 )
*
* where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular
* upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,
* otherwise A23 is (M-K)-by-L upper trapezoidal. K+L = the effective
-* numerical rank of the (M+P)-by-N matrix (A',B')'. Z' denotes the
-* transpose of Z.
+* numerical rank of the (M+P)-by-N matrix (A**T,B**T)**T.
*
* This decomposition is the preprocessing step for computing the
* Generalized Singular Value Decomposition (GSVD), see subroutine
* K (output) INTEGER
* L (output) INTEGER
* On exit, K and L specify the dimension of the subblocks
-* described in Purpose.
-* K + L = effective numerical rank of (A',B')'.
+* described in Purpose section.
+* K + L = effective numerical rank of (A**T,B**T)**T.
*
* U (output) DOUBLE PRECISION array, dimension (LDU,M)
* If JOBU = 'U', U contains the orthogonal matrix U.
*
CALL DGERQ2( L, N, B, LDB, TAU, WORK, INFO )
*
-* Update A := A*Z'
+* Update A := A*Z**T
*
CALL DORMR2( 'Right', 'Transpose', M, N, L, B, LDB, TAU, A,
$ LDA, WORK, INFO )
*
IF( WANTQ ) THEN
*
-* Update Q := Q*Z'
+* Update Q := Q*Z**T
*
CALL DORMR2( 'Right', 'Transpose', N, N, L, B, LDB, TAU, Q,
$ LDQ, WORK, INFO )
*
* then the following does the complete QR decomposition of A11:
*
-* A11 = U*( 0 T12 )*P1'
+* A11 = U*( 0 T12 )*P1**T
* ( 0 0 )
*
DO 70 I = 1, N - L
$ K = K + 1
80 CONTINUE
*
-* Update A12 := U'*A12, where A12 = A( 1:M, N-L+1:N )
+* Update A12 := U**T*A12, where A12 = A( 1:M, N-L+1:N )
*
CALL DORM2R( 'Left', 'Transpose', M, L, MIN( M, N-L ), A, LDA,
$ TAU, A( 1, N-L+1 ), LDA, WORK, INFO )
*
IF( WANTQ ) THEN
*
-* Update Q( 1:N,1:N-L ) = Q( 1:N,1:N-L )*Z1'
+* Update Q( 1:N,1:N-L ) = Q( 1:N,1:N-L )*Z1**T
*
CALL DORMR2( 'Right', 'Transpose', N, N-L, K, A, LDA, TAU,
$ Q, LDQ, WORK, INFO )
$ WORK, N, INFO )
ELSE
*
-* Multiply by inv(L')*inv(U').
+* Multiply by inv(L**T)*inv(U**T).
*
CALL DGTTRS( 'Transpose', N, 1, DL, D, DU, DU2, IPIV, WORK,
$ N, INFO )
* where A is an n by n tridiagonal matrix, by Gaussian elimination with
* partial pivoting.
*
-* Note that the equation A'*X = B may be solved by interchanging the
+* Note that the equation A**T*X = B may be solved by interchanging the
* order of the arguments DU and DL.
*
* Arguments
* DLA_GBAMV performs one of the matrix-vector operations
*
* y := alpha*abs(A)*abs(x) + beta*abs(y),
-* or y := alpha*abs(A)'*abs(x) + beta*abs(y),
+* or y := alpha*abs(A)**T*abs(x) + beta*abs(y),
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
* follows:
*
* BLAS_NO_TRANS y := alpha*abs(A)*abs(x) + beta*abs(y)
-* BLAS_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
-* BLAS_CONJ_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
+* BLAS_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
+* BLAS_CONJ_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
*
* Unchanged on exit.
*
-* M (input) INTEGER
+* M (input) INTEGER
* On entry, M specifies the number of rows of the matrix A.
* M must be at least zero.
* Unchanged on exit.
*
-* N (input) INTEGER
+* N (input) INTEGER
* On entry, N specifies the number of columns of the matrix A.
* N must be at least zero.
* Unchanged on exit.
*
-* KL (input) INTEGER
+* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
-* KU (input) INTEGER
+* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
-* ALPHA - DOUBLE PRECISION
+* ALPHA (input) DOUBLE PRECISION
* On entry, ALPHA specifies the scalar alpha.
* Unchanged on exit.
*
-* A - DOUBLE PRECISION array of DIMENSION ( LDA, n )
-* Before entry, the leading m by n part of the array A must
+* AB (input) DOUBLE PRECISION array of DIMENSION ( LDAB, n )
+* Before entry, the leading m by n part of the array AB must
* contain the matrix of coefficients.
* Unchanged on exit.
*
-* LDA (input) INTEGER
-* On entry, LDA specifies the first dimension of A as declared
-* in the calling (sub) program. LDA must be at least
+* LDAB (input) INTEGER
+* On entry, LDA specifies the first dimension of AB as declared
+* in the calling (sub) program. LDAB must be at least
* max( 1, m ).
* Unchanged on exit.
*
-* X (input) DOUBLE PRECISION array, dimension
+* X (input) DOUBLE PRECISION array, dimension
* ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
* vector x.
* Unchanged on exit.
*
-* INCX (input) INTEGER
+* INCX (input) INTEGER
* On entry, INCX specifies the increment for the elements of
* X. INCX must not be zero.
* Unchanged on exit.
*
-* BETA - DOUBLE PRECISION
+* BETA (input) DOUBLE PRECISION
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input.
* Unchanged on exit.
*
-* Y (input/output) DOUBLE PRECISION array, dimension
+* Y (input/output) DOUBLE PRECISION array, dimension
* ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
* must contain the vector y. On exit, Y is overwritten by the
* updated vector y.
*
-* INCY (input) INTEGER
+* INCY (input) INTEGER
* On entry, INCY specifies the increment for the elements of
* Y. INCY must not be zero.
* Unchanged on exit.
* Level 2 Blas routine.
*
* =====================================================================
-
+*
* .. Parameters ..
DOUBLE PRECISION ONE, ZERO
PARAMETER ( ONE = 1.0D+0, ZERO = 0.0D+0 )
* DLA_GEAMV performs one of the matrix-vector operations
*
* y := alpha*abs(A)*abs(x) + beta*abs(y),
-* or y := alpha*abs(A)'*abs(x) + beta*abs(y),
+* or y := alpha*abs(A)**T*abs(x) + beta*abs(y),
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
* follows:
*
* BLAS_NO_TRANS y := alpha*abs(A)*abs(x) + beta*abs(y)
-* BLAS_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
-* BLAS_CONJ_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
+* BLAS_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
+* BLAS_CONJ_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
*
* Unchanged on exit.
*
-* M (input) INTEGER
+* M (input) INTEGER
* On entry, M specifies the number of rows of the matrix A.
* M must be at least zero.
* Unchanged on exit.
*
-* N (input) INTEGER
+* N (input) INTEGER
* On entry, N specifies the number of columns of the matrix A.
* N must be at least zero.
* Unchanged on exit.
*
-* ALPHA - DOUBLE PRECISION
+* ALPHA (input) DOUBLE PRECISION
* On entry, ALPHA specifies the scalar alpha.
* Unchanged on exit.
*
-* A - DOUBLE PRECISION array of DIMENSION ( LDA, n )
+* A (input) DOUBLE PRECISION array of DIMENSION ( LDA, n )
* Before entry, the leading m by n part of the array A must
* contain the matrix of coefficients.
* Unchanged on exit.
*
-* LDA (input) INTEGER
+* LDA (input) INTEGER
* On entry, LDA specifies the first dimension of A as declared
* in the calling (sub) program. LDA must be at least
* max( 1, m ).
* Unchanged on exit.
*
-* X (input) DOUBLE PRECISION array, dimension
+* X (input) DOUBLE PRECISION array, dimension
* ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
* vector x.
* Unchanged on exit.
*
-* INCX (input) INTEGER
+* INCX (input) INTEGER
* On entry, INCX specifies the increment for the elements of
* X. INCX must not be zero.
* Unchanged on exit.
*
-* BETA - DOUBLE PRECISION
+* BETA (input) DOUBLE PRECISION
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input.
* Unchanged on exit.
*
-* Y - DOUBLE PRECISION
+* Y (input/output) DOUBLE PRECISION
* Array of DIMENSION at least
* ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
* and at least
* must contain the vector y. On exit, Y is overwritten by the
* updated vector y.
*
-* INCY (input) INTEGER
+* INCY (input) INTEGER
* On entry, INCY specifies the increment for the elements of
* Y. INCY must not be zero.
* Unchanged on exit.
*
* DLABRD reduces the first NB rows and columns of a real general
* m by n matrix A to upper or lower bidiagonal form by an orthogonal
-* transformation Q' * A * P, and returns the matrices X and Y which
+* transformation Q**T * A * P, and returns the matrices X and Y which
* are needed to apply the transformation to the unreduced part of A.
*
* If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower
* of A.
*
* LDX (input) INTEGER
-* The leading dimension of the array X. LDX >= M.
+* The leading dimension of the array X. LDX >= max(1,M).
*
* Y (output) DOUBLE PRECISION array, dimension (LDY,NB)
* The n-by-nb matrix Y required to update the unreduced part
* of A.
*
* LDY (input) INTEGER
-* The leading dimension of the array Y. LDY >= N.
+* The leading dimension of the array Y. LDY >= max(1,N).
*
* Further Details
* ===============
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**T and G(i) = I - taup * u * u**T
*
* where tauq and taup are real scalars, and v and u are real vectors.
*
* A(i,i+1:n); tauq is stored in TAUQ(i) and taup in TAUP(i).
*
* The elements of the vectors v and u together form the m-by-nb matrix
-* V and the nb-by-n matrix U' which are needed, with X and Y, to apply
+* V and the nb-by-n matrix U**T which are needed, with X and Y, to apply
* the transformation to the unreduced part of the matrix, using a block
-* update of the form: A := A - V*Y' - X*U'.
+* update of the form: A := A - V*Y**T - X*U**T.
*
* The contents of A on exit are illustrated by the following examples
* with nb = 2:
* the case in which all eigenvalues and eigenvectors of a symmetric
* tridiagonal matrix 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**Tu, u is a vector of length N with ones in the
* CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.
*
* The eigenvectors of the original matrix are stored in Q, and the
DO 110 ITS = 1, N
*
* Solve U*x = scale*v for a right eigenvector
-* or U'*x = scale*v for a left eigenvector,
+* or U**T*x = scale*v for a left eigenvector,
* overwriting x on v.
*
CALL DLATRS( 'Upper', TRANS, 'Nonunit', NORMIN, N, B, LDB,
* DLAGS2 computes 2-by-2 orthogonal matrices U, V and Q, such
* that if ( UPPER ) then
*
-* U'*A*Q = U'*( A1 A2 )*Q = ( x 0 )
-* ( 0 A3 ) ( x x )
+* U**T *A*Q = U**T *( A1 A2 )*Q = ( x 0 )
+* ( 0 A3 ) ( x x )
* and
-* V'*B*Q = V'*( B1 B2 )*Q = ( x 0 )
-* ( 0 B3 ) ( x x )
+* V**T*B*Q = V**T *( B1 B2 )*Q = ( x 0 )
+* ( 0 B3 ) ( x x )
*
* or if ( .NOT.UPPER ) then
*
-* U'*A*Q = U'*( A1 0 )*Q = ( x x )
-* ( A2 A3 ) ( 0 x )
+* U**T *A*Q = U**T *( A1 0 )*Q = ( x x )
+* ( A2 A3 ) ( 0 x )
* and
-* V'*B*Q = V'*( B1 0 )*Q = ( x x )
-* ( B2 B3 ) ( 0 x )
+* V**T*B*Q = V**T*( B1 0 )*Q = ( x x )
+* ( B2 B3 ) ( 0 x )
*
* The rows of the transformed A and B are parallel, where
*
IF( ABS( CSL ).GE.ABS( SNL ) .OR. ABS( CSR ).GE.ABS( SNR ) )
$ THEN
*
-* Compute the (1,1) and (1,2) elements of U'*A and V'*B,
-* and (1,2) element of |U|'*|A| and |V|'*|B|.
+* Compute the (1,1) and (1,2) elements of U**T *A and V**T *B,
+* and (1,2) element of |U|**T *|A| and |V|**T *|B|.
*
UA11R = CSL*A1
UA12 = CSL*A2 + SNL*A3
AUA12 = ABS( CSL )*ABS( A2 ) + ABS( SNL )*ABS( A3 )
AVB12 = ABS( CSR )*ABS( B2 ) + ABS( SNR )*ABS( B3 )
*
-* zero (1,2) elements of U'*A and V'*B
+* zero (1,2) elements of U**T *A and V**T *B
*
IF( ( ABS( UA11R )+ABS( UA12 ) ).NE.ZERO ) THEN
IF( AUA12 / ( ABS( UA11R )+ABS( UA12 ) ).LE.AVB12 /
*
ELSE
*
-* Compute the (2,1) and (2,2) elements of U'*A and V'*B,
-* and (2,2) element of |U|'*|A| and |V|'*|B|.
+* Compute the (2,1) and (2,2) elements of U**T *A and V**T *B,
+* and (2,2) element of |U|**T *|A| and |V|**T *|B|.
*
UA21 = -SNL*A1
UA22 = -SNL*A2 + CSL*A3
AUA22 = ABS( SNL )*ABS( A2 ) + ABS( CSL )*ABS( A3 )
AVB22 = ABS( SNR )*ABS( B2 ) + ABS( CSR )*ABS( B3 )
*
-* zero (2,2) elements of U'*A and V'*B, and then swap.
+* zero (2,2) elements of U**T*A and V**T*B, and then swap.
*
IF( ( ABS( UA21 )+ABS( UA22 ) ).NE.ZERO ) THEN
IF( AUA22 / ( ABS( UA21 )+ABS( UA22 ) ).LE.AVB22 /
IF( ABS( CSR ).GE.ABS( SNR ) .OR. ABS( CSL ).GE.ABS( SNL ) )
$ THEN
*
-* Compute the (2,1) and (2,2) elements of U'*A and V'*B,
-* and (2,1) element of |U|'*|A| and |V|'*|B|.
+* Compute the (2,1) and (2,2) elements of U**T *A and V**T *B,
+* and (2,1) element of |U|**T *|A| and |V|**T *|B|.
*
UA21 = -SNR*A1 + CSR*A2
UA22R = CSR*A3
AUA21 = ABS( SNR )*ABS( A1 ) + ABS( CSR )*ABS( A2 )
AVB21 = ABS( SNL )*ABS( B1 ) + ABS( CSL )*ABS( B2 )
*
-* zero (2,1) elements of U'*A and V'*B.
+* zero (2,1) elements of U**T *A and V**T *B.
*
IF( ( ABS( UA21 )+ABS( UA22R ) ).NE.ZERO ) THEN
IF( AUA21 / ( ABS( UA21 )+ABS( UA22R ) ).LE.AVB21 /
*
ELSE
*
-* Compute the (1,1) and (1,2) elements of U'*A and V'*B,
-* and (1,1) element of |U|'*|A| and |V|'*|B|.
+* Compute the (1,1) and (1,2) elements of U**T *A and V**T *B,
+* and (1,1) element of |U|**T *|A| and |V|**T *|B|.
*
UA11 = CSR*A1 + SNR*A2
UA12 = SNR*A3
AUA11 = ABS( CSR )*ABS( A1 ) + ABS( SNR )*ABS( A2 )
AVB11 = ABS( CSL )*ABS( B1 ) + ABS( SNL )*ABS( B2 )
*
-* zero (1,1) elements of U'*A and V'*B, and then swap.
+* zero (1,1) elements of U**T*A and V**T*B, and then swap.
*
IF( ( ABS( UA11 )+ABS( UA12 ) ).NE.ZERO ) THEN
IF( AUA11 / ( ABS( UA11 )+ABS( UA12 ) ).LE.AVB11 /
60 CONTINUE
ELSE
*
-* Compute B := B + A'*X
+* Compute B := B + A**T*X
*
DO 80 J = 1, NRHS
IF( N.EQ.1 ) THEN
100 CONTINUE
ELSE
*
-* Compute B := B - A'*X
+* Compute B := B - A**T*X
*
DO 120 J = 1, NRHS
IF( N.EQ.1 ) THEN
*
* DLAGTS may be used to solve one of the systems of equations
*
-* (T - lambda*I)*x = y or (T - lambda*I)'*x = y,
+* (T - lambda*I)*x = y or (T - lambda*I)**T*x = y,
*
* where T is an n by n tridiagonal matrix, for x, following the
* factorization of (T - lambda*I) as
* and, if overflow would otherwise occur, the diagonal
* elements of U are to be perturbed. See argument TOL
* below.
-* = 2: The equations (T - lambda*I)'x = y are to be solved,
+* = 2: The equations (T - lambda*I)**Tx = y are to be solved,
* but diagonal elements of U are not to be perturbed.
-* = -2: The equations (T - lambda*I)'x = y are to be solved
+* = -2: The equations (T - lambda*I)**Tx = y are to be solved
* and, if overflow would otherwise occur, the diagonal
* elements of U are to be perturbed. See argument TOL
* below.
* DLAHR2 reduces the first NB columns of A real general n-BY-(n-k+1)
* matrix A so that elements below the k-th subdiagonal are zero. The
* reduction is performed by an orthogonal similarity transformation
-* Q' * A * Q. The routine returns the matrices V and T which determine
-* Q as a block reflector I - V*T*V', and also the matrix Y = A * V * T.
+* Q**T * A * Q. The routine returns the matrices V and T which determine
+* Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T.
*
* This is an auxiliary routine called by DGEHRD.
*
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit in
* The elements of the vectors v together form the (n-k+1)-by-nb matrix
* V which is needed, with T and Y, to apply the transformation to the
* unreduced part of the matrix, using an update of the form:
-* A := (I - V*T*V') * (A - Y*V').
+* A := (I - V*T*V**T) * (A - Y*V**T).
*
* The contents of A on exit are illustrated by the following example
* with n = 7, k = 3 and nb = 2:
*
* Update A(K+1:N,I)
*
-* Update I-th column of A - Y * V'
+* Update I-th column of A - Y * V**T
*
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' to this column (call it b) from the
+* Apply I - V * 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)
$ I-1, A( K+1, 1 ),
$ LDA, T( 1, NB ), 1 )
*
-* w := w + V2'*b2
+* w := w + V2**T * b2
*
CALL DGEMV( 'Transpose', N-K-I+1, I-1,
$ ONE, A( K+I, 1 ),
$ LDA, A( K+I, I ), 1, ONE, T( 1, NB ), 1 )
*
-* w := T'*w
+* w := T**T * w
*
CALL DTRMV( 'Upper', 'Transpose', 'NON-UNIT',
$ I-1, T, LDT,
* DLAHRD reduces the first NB columns of a real general n-by-(n-k+1)
* matrix A so that elements below the k-th subdiagonal are zero. The
* reduction is performed by an orthogonal similarity transformation
-* Q' * A * Q. The routine returns the matrices V and T which determine
-* Q as a block reflector I - V*T*V', and also the matrix Y = A * V * T.
+* Q**T * A * Q. The routine returns the matrices V and T which determine
+* Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T.
*
* This is an OBSOLETE auxiliary routine.
* This routine will be 'deprecated' in a future release.
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit in
* The elements of the vectors v together form the (n-k+1)-by-nb matrix
* V which is needed, with T and Y, to apply the transformation to the
* unreduced part of the matrix, using an update of the form:
-* A := (I - V*T*V') * (A - Y*V').
+* A := (I - V*T*V**T) * (A - Y*V**T).
*
* The contents of A on exit are illustrated by the following example
* with n = 7, k = 3 and nb = 2:
*
* Update A(1:n,i)
*
-* Compute i-th column of A - Y * V'
+* Compute i-th column of A - Y * V**T
*
CALL DGEMV( 'No transpose', N, I-1, -ONE, Y, LDY,
$ A( K+I-1, 1 ), LDA, ONE, A( 1, I ), 1 )
*
-* Apply I - V * T' * V' 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', I-1, A( K+1, 1 ),
$ LDA, T( 1, NB ), 1 )
*
-* w := w + V2'*b2
+* w := w + V2**T *b2
*
CALL DGEMV( 'Transpose', N-K-I+1, I-1, ONE, A( K+I, 1 ),
$ LDA, A( K+I, I ), 1, ONE, T( 1, NB ), 1 )
*
-* w := T'*w
+* w := T**T *w
*
CALL DTRMV( 'Upper', 'Transpose', 'Non-unit', I-1, T, LDT,
$ T( 1, NB ), 1 )
* diag(sest*sest, 0) + [alpha gamma] * [ alpha ]
* [ gamma ]
*
-* where alpha = x'*w.
+* where alpha = x**T*w.
*
* Arguments
* =========
*
IF( I.LE.N ) THEN
*
-* Apply H(i)' to A(offset+i:m,i+1:n) from the left.
+* Apply H(i)**T to A(offset+i:m,i+1:n) from the left.
*
AII = A( OFFPI, I )
A( OFFPI, I ) = ONE
END IF
*
* Apply previous Householder reflectors to column K:
-* A(RK:M,K) := A(RK:M,K) - A(RK:M,1:K-1)*F(K,1:K-1)'.
+* A(RK:M,K) := A(RK:M,K) - A(RK:M,1:K-1)*F(K,1:K-1)**T.
*
IF( K.GT.1 ) THEN
CALL DGEMV( 'No transpose', M-RK+1, K-1, -ONE, A( RK, 1 ),
*
* Compute Kth column of F:
*
-* Compute F(K+1:N,K) := tau(K)*A(RK:M,K+1:N)'*A(RK:M,K).
+* Compute F(K+1:N,K) := tau(K)*A(RK:M,K+1:N)**T*A(RK:M,K).
*
IF( K.LT.N ) THEN
CALL DGEMV( 'Transpose', M-RK+1, N-K, TAU( K ),
20 CONTINUE
*
* Incremental updating of F:
-* F(1:N,K) := F(1:N,K) - tau(K)*F(1:N,1:K-1)*A(RK:M,1:K-1)'
+* F(1:N,K) := F(1:N,K) - tau(K)*F(1:N,1:K-1)*A(RK:M,1:K-1)**T
* *A(RK:M,K).
*
IF( K.GT.1 ) THEN
END IF
*
* Update the current row of A:
-* A(RK,K+1:N) := A(RK,K+1:N) - A(RK,1:K)*F(K+1:N,1:K)'.
+* A(RK,K+1:N) := A(RK,K+1:N) - A(RK,1:K)*F(K+1:N,1:K)**T.
*
IF( K.LT.N ) THEN
CALL DGEMV( 'No transpose', N-K, K, -ONE, F( K+1, 1 ), LDF,
*
* Apply the block reflector to the rest of the matrix:
* A(OFFSET+KB+1:M,KB+1:N) := A(OFFSET+KB+1:M,KB+1:N) -
-* A(OFFSET+KB+1:M,1:KB)*F(KB+1:N,1:KB)'.
+* A(OFFSET+KB+1:M,1:KB)*F(KB+1:N,1:KB)**T.
*
IF( KB.LT.MIN( N, M-OFFSET ) ) THEN
CALL DGEMM( 'No transpose', 'Transpose', M-RK, N-KB, KB, -ONE,
* if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
*
* On exit, if INFO = 0, the triangular factor U or L from the
-* Cholesky factorization A = U'*U or A = L*L' of the band
+* Cholesky factorization A = U**T*U or A = L*L**T of the band
* matrix A, in the same storage format as A.
*
* LDAB (input) INTEGER
* LTRAN (input) LOGICAL
* On entry, LTRAN specifies the option of conjugate transpose:
* = .FALSE., op(T+i*B) = T+i*B,
-* = .TRUE., op(T+i*B) = (T+i*B)'.
+* = .TRUE., op(T+i*B) = (T+i*B)**T.
*
* LREAL (input) LOGICAL
* On entry, LREAL specifies the input matrix structure:
*
ELSE
*
-* Solve (T + iB)'*(p+iq) = c+id
+* Solve (T + iB)**T*(p+iq) = c+id
*
JNEXT = 1
DO 80 J = 1, N
*
* DLAR1V computes the (scaled) r-th column of the inverse of
* the sumbmatrix in rows B1 through BN of the tridiagonal matrix
-* L D L^T - sigma I. When sigma is close to an eigenvalue, the
+* L D L**T - sigma I. When sigma is close to an eigenvalue, the
* computed vector is an accurate eigenvector. Usually, r corresponds
* to the index where the eigenvector is largest in magnitude.
* The following steps accomplish this computation :
-* (a) Stationary qd transform, L D L^T - sigma I = L(+) D(+) L(+)^T,
-* (b) Progressive qd transform, L D L^T - sigma I = U(-) D(-) U(-)^T,
+* (a) Stationary qd transform, L D L**T - sigma I = L(+) D(+) L(+)**T,
+* (b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,
* (c) Computation of the diagonal elements of the inverse of
-* L D L^T - sigma I by combining the above transforms, and choosing
+* L D L**T - sigma I by combining the above transforms, and choosing
* r as the index where the diagonal of the inverse is (one of the)
* largest in magnitude.
* (d) Computation of the (scaled) r-th column of the inverse using the
* =========
*
* N (input) INTEGER
-* The order of the matrix L D L^T.
+* The order of the matrix L D L**T.
*
* B1 (input) INTEGER
-* First index of the submatrix of L D L^T.
+* First index of the submatrix of L D L**T.
*
* BN (input) INTEGER
-* Last index of the submatrix of L D L^T.
+* Last index of the submatrix of L D L**T.
*
* LAMBDA (input) DOUBLE PRECISION
* The shift. In order to compute an accurate eigenvector,
* LAMBDA should be a good approximation to an eigenvalue
-* of L D L^T.
+* of L D L**T.
*
* L (input) DOUBLE PRECISION array, dimension (N-1)
* The (n-1) subdiagonal elements of the unit bidiagonal matrix
*
* NEGCNT (output) INTEGER
* If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin
-* in the matrix factorization L D L^T, and NEGCNT = -1 otherwise.
+* in the matrix factorization L D L**T, and NEGCNT = -1 otherwise.
*
* ZTZ (output) DOUBLE PRECISION
* The square of the 2-norm of Z.
*
* MINGMA (output) DOUBLE PRECISION
* The reciprocal of the largest (in magnitude) diagonal
-* element of the inverse of L D L^T - sigma I.
+* element of the inverse of L D L**T - sigma I.
*
* R (input/output) INTEGER
* The twist index for the twisted factorization used to
* compute Z.
* On input, 0 <= R <= N. If R is input as 0, R is set to
-* the index where (L D L^T - sigma I)^{-1} is largest
+* the index where (L D L**T - sigma I)^{-1} is largest
* in magnitude. If 1 <= R <= N, R is unchanged.
* On output, R contains the twist index used to compute Z.
* Ideally, R designates the position of the maximum entry in the
* DLARF applies a real elementary reflector H to a real m by n matrix
* C, from either the left or the right. H is represented in the form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**T
*
* where tau is a real scalar and v is a real vector.
*
*
IF( LASTV.GT.0 ) THEN
*
-* w(1:lastc,1) := C(1:lastv,1:lastc)' * v(1:lastv,1)
+* w(1:lastc,1) := C(1:lastv,1:lastc)**T * v(1:lastv,1)
*
CALL DGEMV( 'Transpose', LASTV, LASTC, ONE, C, LDC, V, INCV,
$ ZERO, WORK, 1 )
*
-* C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)'
+* C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)**T
*
CALL DGER( LASTV, LASTC, -TAU, V, INCV, WORK, 1, C, LDC )
END IF
CALL DGEMV( 'No transpose', LASTC, LASTV, ONE, C, LDC,
$ V, INCV, ZERO, WORK, 1 )
*
-* C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)'
+* C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)**T
*
CALL DGER( LASTC, LASTV, -TAU, WORK, 1, V, INCV, C, LDC )
END IF
* Purpose
* =======
*
-* DLARFB applies a real block reflector H or its transpose H' to a
+* DLARFB applies a real block reflector H or its transpose H**T to a
* real m by n matrix C, from either the left or the right.
*
* Arguments
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply H or H' from the Left
-* = 'R': apply H or H' from the Right
+* = 'L': apply H or H**T from the Left
+* = 'R': apply H or H**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply H (No transpose)
-* = 'T': apply H' (Transpose)
+* = 'T': apply H**T (Transpose)
*
* DIRECT (input) CHARACTER*1
* Indicates how H is formed from a product of elementary
*
* C (input/output) DOUBLE PRECISION array, dimension (LDC,N)
* On entry, the m by n matrix C.
-* On exit, C is overwritten by H*C or H'*C or C*H or C*H'.
+* On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T.
*
* LDC (input) INTEGER
-* The leading dimension of the array C. LDA >= max(1,M).
+* The leading dimension of the array C. LDC >= max(1,M).
*
* WORK (workspace) DOUBLE PRECISION array, dimension (LDWORK,K)
*
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**T * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILADLR( M, K, V, LDV ) )
LASTC = ILADLC( LASTV, N, C, LDC )
*
-* W := C' * V = (C1'*V1 + C2'*V2) (stored in WORK)
+* W := C**T * V = (C1**T * V1 + C2**T * V2) (stored in WORK)
*
-* W := C1'
+* W := C1**T
*
DO 10 J = 1, K
CALL DCOPY( LASTC, C( J, 1 ), LDC, WORK( 1, J ), 1 )
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2'*V2
+* W := W + C2**T *V2
*
CALL DGEMM( 'Transpose', 'No transpose',
$ LASTC, K, LASTV-K,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**T or W * T
*
CALL DTRMM( 'Right', 'Upper', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V * W'
+* C := C - V * W**T
*
IF( LASTV.GT.K ) THEN
*
-* C2 := C2 - V2 * W'
+* C2 := C2 - V2 * W**T
*
CALL DGEMM( 'No transpose', 'Transpose',
$ LASTV-K, LASTC, K,
$ C( K+1, 1 ), LDC )
END IF
*
-* W := W * V1'
+* W := W * V1**T
*
CALL DTRMM( 'Right', 'Lower', 'Transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
-* C1 := C1 - W'
+* C1 := C1 - W**T
*
DO 30 J = 1, K
DO 20 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**T where C = ( C1 C2 )
*
LASTV = MAX( K, ILADLR( N, K, V, LDV ) )
LASTC = ILADLR( M, LASTV, C, LDC )
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**T
*
CALL DTRMM( 'Right', 'Upper', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - W * V'
+* C := C - W * V**T
*
IF( LASTV.GT.K ) THEN
*
-* C2 := C2 - W * V2'
+* C2 := C2 - W * V2**T
*
CALL DGEMM( 'No transpose', 'Transpose',
$ LASTC, LASTV-K, K,
$ C( 1, K+1 ), LDC )
END IF
*
-* W := W * V1'
+* W := W * V1**T
*
CALL DTRMM( 'Right', 'Lower', 'Transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**T * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILADLR( M, K, V, LDV ) )
LASTC = ILADLC( LASTV, N, C, LDC )
*
-* W := C' * V = (C1'*V1 + C2'*V2) (stored in WORK)
+* W := C' * V = (C1**T * V1 + C2**T * V2) (stored in WORK)
*
-* W := C2'
+* W := C2**T
*
DO 70 J = 1, K
CALL DCOPY( LASTC, C( LASTV-K+J, 1 ), LDC,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1'*V1
+* W := W + C1**T*V1
*
CALL DGEMM( 'Transpose', 'No transpose',
$ LASTC, K, LASTV-K, ONE, C, LDC, V, LDV,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**T or W * T
*
CALL DTRMM( 'Right', 'Lower', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V * W'
+* C := C - V * W**T
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - V1 * W'
+* C1 := C1 - V1 * W**T
*
CALL DGEMM( 'No transpose', 'Transpose',
$ LASTV-K, LASTC, K, -ONE, V, LDV, WORK, LDWORK,
$ ONE, C, LDC )
END IF
*
-* W := W * V2'
+* W := W * V2**T
*
CALL DTRMM( 'Right', 'Upper', 'Transpose', 'Unit',
$ LASTC, K, ONE, V( LASTV-K+1, 1 ), LDV,
$ WORK, LDWORK )
*
-* C2 := C2 - W'
+* C2 := C2 - W**T
*
DO 90 J = 1, K
DO 80 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**T where C = ( C1 C2 )
*
LASTV = MAX( K, ILADLR( N, K, V, LDV ) )
LASTC = ILADLR( M, LASTV, C, LDC )
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**T
*
CALL DTRMM( 'Right', 'Lower', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - W * V1'
+* C1 := C1 - W * V1**T
*
CALL DGEMM( 'No transpose', 'Transpose',
$ LASTC, LASTV-K, K, -ONE, WORK, LDWORK, V, LDV,
$ ONE, C, LDC )
END IF
*
-* W := W * V2'
+* W := W * V2**T
*
CALL DTRMM( 'Right', 'Upper', 'Transpose', 'Unit',
$ LASTC, K, ONE, V( LASTV-K+1, 1 ), LDV,
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**T * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILADLC( K, M, V, LDV ) )
LASTC = ILADLC( LASTV, N, C, LDC )
*
-* W := C' * V' = (C1'*V1' + C2'*V2') (stored in WORK)
+* W := C**T * V**T = (C1**T * V1**T + C2**T * V2**T) (stored in WORK)
*
-* W := C1'
+* W := C1**T
*
DO 130 J = 1, K
CALL DCOPY( LASTC, C( J, 1 ), LDC, WORK( 1, J ), 1 )
130 CONTINUE
*
-* W := W * V1'
+* W := W * V1**T
*
CALL DTRMM( 'Right', 'Upper', 'Transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2'*V2'
+* W := W + C2**T*V2**T
*
CALL DGEMM( 'Transpose', 'Transpose',
$ LASTC, K, LASTV-K,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**T or W * T
*
CALL DTRMM( 'Right', 'Upper', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V' * W'
+* C := C - V**T * W**T
*
IF( LASTV.GT.K ) THEN
*
-* C2 := C2 - V2' * W'
+* C2 := C2 - V2**T * W**T
*
CALL DGEMM( 'Transpose', 'Transpose',
$ LASTV-K, LASTC, K,
CALL DTRMM( 'Right', 'Upper', 'No transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
-* C1 := C1 - W'
+* C1 := C1 - W**T
*
DO 150 J = 1, K
DO 140 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**T where C = ( C1 C2 )
*
LASTV = MAX( K, ILADLC( K, N, V, LDV ) )
LASTC = ILADLR( M, LASTV, C, LDC )
*
-* W := C * V' = (C1*V1' + C2*V2') (stored in WORK)
+* W := C * V**T = (C1*V1**T + C2*V2**T) (stored in WORK)
*
* W := C1
*
CALL DCOPY( LASTC, C( 1, J ), 1, WORK( 1, J ), 1 )
160 CONTINUE
*
-* W := W * V1'
+* W := W * V1**T
*
CALL DTRMM( 'Right', 'Upper', 'Transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2 * V2'
+* W := W + C2 * V2**T
*
CALL DGEMM( 'No transpose', 'Transpose',
$ LASTC, K, LASTV-K,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**T
*
CALL DTRMM( 'Right', 'Upper', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**T * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILADLC( K, M, V, LDV ) )
LASTC = ILADLC( LASTV, N, C, LDC )
*
-* W := C' * V' = (C1'*V1' + C2'*V2') (stored in WORK)
+* W := C**T * V**T = (C1**T * V1**T + C2**T * V2**T) (stored in WORK)
*
-* W := C2'
+* W := C2**T
*
DO 190 J = 1, K
CALL DCOPY( LASTC, C( LASTV-K+J, 1 ), LDC,
$ WORK( 1, J ), 1 )
190 CONTINUE
*
-* W := W * V2'
+* W := W * V2**T
*
CALL DTRMM( 'Right', 'Lower', 'Transpose', 'Unit',
$ LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1'*V1'
+* W := W + C1**T * V1**T
*
CALL DGEMM( 'Transpose', 'Transpose',
$ LASTC, K, LASTV-K, ONE, C, LDC, V, LDV,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**T or W * T
*
CALL DTRMM( 'Right', 'Lower', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V' * W'
+* C := C - V**T * W**T
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - V1' * W'
+* C1 := C1 - V1**T * W**T
*
CALL DGEMM( 'Transpose', 'Transpose',
$ LASTV-K, LASTC, K, -ONE, V, LDV, WORK, LDWORK,
$ LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
*
-* C2 := C2 - W'
+* C2 := C2 - W**T
*
DO 210 J = 1, K
DO 200 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**T where C = ( C1 C2 )
*
LASTV = MAX( K, ILADLC( K, N, V, LDV ) )
LASTC = ILADLR( M, LASTV, C, LDC )
*
-* W := C * V' = (C1*V1' + C2*V2') (stored in WORK)
+* W := C * V**T = (C1*V1**T + C2*V2**T) (stored in WORK)
*
* W := C2
*
$ WORK( 1, J ), 1 )
220 CONTINUE
*
-* W := W * V2'
+* W := W * V2**T
*
CALL DTRMM( 'Right', 'Lower', 'Transpose', 'Unit',
$ LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1 * V1'
+* W := W + C1 * V1**T
*
CALL DGEMM( 'No transpose', 'Transpose',
$ LASTC, K, LASTV-K, ONE, C, LDC, V, LDV,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**T
*
CALL DTRMM( 'Right', 'Lower', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
* DLARFG generates a real elementary reflector H of order n, such
* that
*
-* H * ( alpha ) = ( beta ), H' * H = I.
+* H * ( alpha ) = ( beta ), H**T * H = I.
* ( x ) ( 0 )
*
* where alpha and beta are scalars, and x is an (n-1)-element real
* vector. H is represented in the form
*
-* H = I - tau * ( 1 ) * ( 1 v' ) ,
+* H = I - tau * ( 1 ) * ( 1 v**T ) ,
* ( v )
*
* where tau is a real scalar and v is a real (n-1)-element
* DLARFGP generates a real elementary reflector H of order n, such
* that
*
-* H * ( alpha ) = ( beta ), H' * H = I.
+* H * ( alpha ) = ( beta ), H**T * H = I.
* ( x ) ( 0 )
*
* where alpha and beta are scalars, beta is non-negative, and x is
* an (n-1)-element real vector. H is represented in the form
*
-* H = I - tau * ( 1 ) * ( 1 v' ) ,
+* H = I - tau * ( 1 ) * ( 1 v**T ) ,
* ( v )
*
* where tau is a real scalar and v is a real (n-1)-element
* 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
*
* Arguments
* =========
END DO
J = MIN( LASTV, PREVLASTV )
*
-* T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)' * V(i:j,i)
+* T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)**T * V(i:j,i)
*
CALL DGEMV( 'Transpose', J-I+1, I-1, -TAU( I ),
$ V( I, 1 ), LDV, V( I, I ), 1, ZERO,
END DO
J = MIN( LASTV, PREVLASTV )
*
-* T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)'
+* T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)**T
*
CALL DGEMV( 'No transpose', I-1, J-I+1, -TAU( I ),
$ V( 1, I ), LDV, V( I, I ), LDV, ZERO,
J = MAX( LASTV, PREVLASTV )
*
* T(i+1:k,i) :=
-* - tau(i) * V(j:n-k+i,i+1:k)' * V(j:n-k+i,i)
+* - tau(i) * V(j:n-k+i,i+1:k)**T * V(j:n-k+i,i)
*
CALL DGEMV( 'Transpose', N-K+I-J+1, K-I, -TAU( I ),
$ V( J, I+1 ), LDV, V( J, I ), 1, ZERO,
J = MAX( LASTV, PREVLASTV )
*
* T(i+1:k,i) :=
-* - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)'
+* - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)**T
*
CALL DGEMV( 'No transpose', K-I, N-K+I-J+1,
$ -TAU( I ), V( I+1, J ), LDV, V( I, J ), LDV,
* matrix C, from either the left or the right. H is represented in the
* form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**T
*
* where tau is a real scalar and v is a real vector.
*
* =======
*
* DLARRV computes the eigenvectors of the tridiagonal matrix
-* T = L D L^T given L, D and APPROXIMATIONS to the eigenvalues of L D L^T.
+* T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T.
* The input eigenvalues should have been computed by DLARRE.
*
* Arguments
* matrix C, from either the left or the right. H is represented in the
* form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**T
*
* where tau is a real scalar and v is a real vector.
*
*
CALL DCOPY( N, C, LDC, WORK, 1 )
*
-* w( 1:n ) = w( 1:n ) + C( m-l+1:m, 1:n )' * v( 1:l )
+* w( 1:n ) = w( 1:n ) + C( m-l+1:m, 1:n )**T * v( 1:l )
*
CALL DGEMV( 'Transpose', L, N, ONE, C( M-L+1, 1 ), LDC, V,
$ INCV, ONE, WORK, 1 )
CALL DAXPY( N, -TAU, WORK, 1, C, LDC )
*
* C( m-l+1:m, 1:n ) = C( m-l+1:m, 1:n ) - ...
-* tau * v( 1:l ) * w( 1:n )'
+* tau * v( 1:l ) * w( 1:n )**T
*
CALL DGER( L, N, -TAU, V, INCV, WORK, 1, C( M-L+1, 1 ),
$ LDC )
CALL DAXPY( M, -TAU, WORK, 1, C, 1 )
*
* C( 1:m, n-l+1:n ) = C( 1:m, n-l+1:n ) - ...
-* tau * w( 1:m ) * v( 1:l )'
+* tau * w( 1:m ) * v( 1:l )**T
*
CALL DGER( M, L, -TAU, WORK, 1, V, INCV, C( 1, N-L+1 ),
$ LDC )
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply H or H' from the Left
-* = 'R': apply H or H' from the Right
+* = 'L': apply H or H**T from the Left
+* = 'R': apply H or H**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply H (No transpose)
-* = 'C': apply H' (Transpose)
+* = 'C': apply H**T (Transpose)
*
* DIRECT (input) CHARACTER*1
* Indicates how H is formed from a product of elementary
*
* C (input/output) DOUBLE PRECISION array, dimension (LDC,N)
* On entry, the M-by-N matrix C.
-* On exit, C is overwritten by H*C or H'*C or C*H or C*H'.
+* On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C
+* Form H * C or H**T * C
*
-* W( 1:n, 1:k ) = C( 1:k, 1:n )'
+* W( 1:n, 1:k ) = C( 1:k, 1:n )**T
*
DO 10 J = 1, K
CALL DCOPY( N, C( J, 1 ), LDC, WORK( 1, J ), 1 )
10 CONTINUE
*
* W( 1:n, 1:k ) = W( 1:n, 1:k ) + ...
-* C( m-l+1:m, 1:n )' * V( 1:k, 1:l )'
+* C( m-l+1:m, 1:n )**T * V( 1:k, 1:l )**T
*
IF( L.GT.0 )
$ CALL DGEMM( 'Transpose', 'Transpose', N, K, L, ONE,
CALL DTRMM( 'Right', 'Lower', TRANST, 'Non-unit', N, K, ONE, T,
$ LDT, WORK, LDWORK )
*
-* C( 1:k, 1:n ) = C( 1:k, 1:n ) - W( 1:n, 1:k )'
+* C( 1:k, 1:n ) = C( 1:k, 1:n ) - W( 1:n, 1:k )**T
*
DO 30 J = 1, N
DO 20 I = 1, K
30 CONTINUE
*
* C( m-l+1:m, 1:n ) = C( m-l+1:m, 1:n ) - ...
-* V( 1:k, 1:l )' * W( 1:n, 1:k )'
+* V( 1:k, 1:l )**T * W( 1:n, 1:k )**T
*
IF( L.GT.0 )
$ CALL DGEMM( 'Transpose', 'Transpose', L, N, K, -ONE, V, LDV,
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H'
+* Form C * H or C * H**T
*
* W( 1:m, 1:k ) = C( 1:m, 1:k )
*
40 CONTINUE
*
* W( 1:m, 1:k ) = W( 1:m, 1:k ) + ...
-* C( 1:m, n-l+1:n ) * V( 1:k, 1:l )'
+* C( 1:m, n-l+1:n ) * V( 1:k, 1:l )**T
*
IF( L.GT.0 )
$ CALL DGEMM( 'No transpose', 'Transpose', M, K, L, ONE,
$ C( 1, N-L+1 ), LDC, V, LDV, ONE, WORK, LDWORK )
*
-* W( 1:m, 1:k ) = W( 1:m, 1:k ) * T or W( 1:m, 1:k ) * T'
+* W( 1:m, 1:k ) = W( 1:m, 1:k ) * T or W( 1:m, 1:k ) * T**T
*
CALL DTRMM( 'Right', 'Lower', TRANS, 'Non-unit', M, K, ONE, T,
$ LDT, WORK, LDWORK )
*
IF( I.LT.K ) THEN
*
-* T(i+1:k,i) = - tau(i) * V(i+1:k,1:n) * V(i,1:n)'
+* T(i+1:k,i) = - tau(i) * V(i+1:k,1:n) * V(i,1:n)**T
*
CALL DGEMV( 'No transpose', K-I, N, -TAU( I ),
$ V( I+1, 1 ), LDV, V( I, 1 ), LDV, ZERO,
*
* VT (input/output) DOUBLE PRECISION array, dimension(LDVT,M)
* where M = N + SQRE.
-* On entry VT(1:NL+1, 1:NL+1)' contains the right singular
-* vectors of the upper block; VT(NL+2:M, NL+2:M)' contains
+* 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
* bidiagonal matrix.
* using the Bunch-Kaufman diagonal pivoting method. The partial
* factorization has the form:
*
-* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
-* ( 0 U22 ) ( 0 D ) ( U12' U22' )
+* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
+* ( 0 U22 ) ( 0 D ) ( U12**T U22**T )
*
-* A = ( L11 0 ) ( D 0 ) ( L11' L21' ) if UPLO = 'L'
-* ( L21 I ) ( 0 A22 ) ( 0 I )
+* A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L'
+* ( L21 I ) ( 0 A22 ) ( 0 I )
*
* where the order of D is at most NB. The actual order is returned in
* the argument KB, and is either NB or NB-1, or N if N <= NB.
*
* Update the upper triangle of A11 (= A(1:k,1:k)) as
*
-* A11 := A11 - U12*D*U12' = A11 - U12*W'
+* A11 := A11 - U12*D*U12**T = A11 - U12*W**T
*
* computing blocks of NB columns at a time
*
*
* Update the lower triangle of A22 (= A(k:n,k:n)) as
*
-* A22 := A22 - L21*D*L21' = A22 - L21*W'
+* A22 := A22 - L21*D*L21**T = A22 - L21*W**T
*
* computing blocks of NB columns at a time
*
*
* DLATRD reduces NB rows and columns of a real symmetric matrix A to
* symmetric tridiagonal form by an orthogonal similarity
-* transformation Q' * A * Q, and returns the matrices V and W which are
+* transformation Q**T * A * Q, and returns the matrices V and W which are
* needed to apply the transformation to the unreduced part of A.
*
* If UPLO = 'U', DLATRD reduces the last NB rows and columns of a
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(i:n) = 0 and v(i-1) = 1; v(1:i-1) is stored on exit in A(1:i-1,i),
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+1:n) is stored on exit in A(i+1:n,i),
* The elements of the vectors v together form the n-by-nb matrix V
* which is needed, with W, to apply the transformation to the unreduced
* part of the matrix, using a symmetric rank-2k update of the form:
-* A := A - V*W' - W*V'.
+* A := A - V*W**T - W*V**T.
*
* The contents of A on exit are illustrated by the following examples
* with n = 5 and nb = 2:
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
+* T( k ) = I - tau*u( k )*u( k )**T, u( k ) = ( 1 ),
* ( 0 )
* ( z( k ) )
*
*
* DLATZM applies a Householder matrix generated by DTZRQF to a matrix.
*
-* Let P = I - tau*u*u', u = ( 1 ),
-* ( v )
+* Let P = I - tau*u*u**T, u = ( 1 ),
+* ( v )
* where v is an (m-1) vector if SIDE = 'L', or a (n-1) vector if
* SIDE = 'R'.
*
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* w := C1 + v' * C2
+* w := (C1 + v**T * C2)**T
*
CALL DCOPY( N, C1, LDC, WORK, 1 )
CALL DGEMV( 'Transpose', M-1, N, ONE, C2, LDC, V, INCV, ONE,
$ WORK, 1 )
*
-* [ C1 ] := [ C1 ] - tau* [ 1 ] * w'
+* [ C1 ] := [ C1 ] - tau* [ 1 ] * w**T
* [ C2 ] [ C2 ] [ v ]
*
CALL DAXPY( N, -TAU, WORK, 1, C1, LDC )
CALL DGEMV( 'No transpose', M, N-1, ONE, C2, LDC, V, INCV, ONE,
$ WORK, 1 )
*
-* [ C1, C2 ] := [ C1, C2 ] - tau* w * [ 1 , v']
+* [ C1, C2 ] := [ C1, C2 ] - tau* w * [ 1 , v**T]
*
CALL DAXPY( M, -TAU, WORK, 1, C1, 1 )
CALL DGER( M, N-1, -TAU, WORK, 1, V, INCV, C2, LDC )
* Purpose
* =======
*
-* DLAUU2 computes the product U * U' or L' * L, where the triangular
+* DLAUU2 computes the product U * U**T or L**T * L, where the triangular
* factor U or L is stored in the upper or lower triangular part of
* the array A.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the triangular factor U or L.
* On exit, if UPLO = 'U', the upper triangle of A is
-* overwritten with the upper triangle of the product U * U';
+* overwritten with the upper triangle of the product U * U**T;
* if UPLO = 'L', the lower triangle of A is overwritten with
-* the lower triangle of the product L' * L.
+* the lower triangle of the product L**T * L.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the product U * U'.
+* Compute the product U * U**T.
*
DO 10 I = 1, N
AII = A( I, I )
*
ELSE
*
-* Compute the product L' * L.
+* Compute the product L**T * L.
*
DO 20 I = 1, N
AII = A( I, I )
* Purpose
* =======
*
-* DLAUUM computes the product U * U' or L' * L, where the triangular
+* DLAUUM computes the product U * U**T or L**T * L, where the triangular
* factor U or L is stored in the upper or lower triangular part of
* the array A.
*
* A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
* On entry, the triangular factor U or L.
* On exit, if UPLO = 'U', the upper triangle of A is
-* overwritten with the upper triangle of the product U * U';
+* overwritten with the upper triangle of the product U * U**T;
* if UPLO = 'L', the lower triangle of A is overwritten with
-* the lower triangle of the product L' * L.
+* the lower triangle of the product L**T * L.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the product U * U'.
+* Compute the product U * U**T.
*
DO 10 I = 1, N, NB
IB = MIN( NB, N-I+1 )
10 CONTINUE
ELSE
*
-* Compute the product L' * L.
+* Compute the product L**T * L.
*
DO 20 I = 1, N, NB
IB = MIN( NB, N-I+1 )
CALL DLARFT( 'Forward', 'Rowwise', N-I+1, IB, A( I, I ),
$ LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i+ib:m,i:n) from the right
+* Apply H**T to A(i+ib:m,i:n) from the right
*
CALL DLARFB( 'Right', 'Transpose', 'Forward', 'Rowwise',
$ M-I-IB+1, N-I+1, IB, A( I, I ), LDA, WORK,
$ LDWORK )
END IF
*
-* Apply H' to columns i:n of current block
+* Apply H**T to columns i:n of current block
*
CALL DORGL2( IB, N-I+1, IB, A( I, I ), LDA, TAU( I ), WORK,
$ IINFO )
CALL DLARFT( 'Backward', 'Rowwise', N-K+I+IB-1, IB,
$ A( II, 1 ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(1:m-k+i-1,1:n-k+i+ib-1) from the right
+* Apply H**T to A(1:m-k+i-1,1:n-k+i+ib-1) from the right
*
CALL DLARFB( 'Right', 'Transpose', 'Backward', 'Rowwise',
$ II-1, N-K+I+IB-1, IB, A( II, 1 ), LDA, WORK,
$ LDWORK, A, LDA, WORK( IB+1 ), LDWORK )
END IF
*
-* Apply H' to columns 1:n-k+i+ib-1 of current block
+* Apply H**T to columns 1:n-k+i+ib-1 of current block
*
CALL DORGR2( IB, N-K+I+IB-1, IB, A( II, 1 ), LDA, TAU( I ),
$ WORK, IINFO )
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'T', or
+* Q**T * C if SIDE = 'L' and TRANS = 'T', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'T',
+* C * Q**T if SIDE = 'R' and TRANS = 'T',
*
* where Q is a real orthogonal matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**T from the Left
+* = 'R': apply Q or Q**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'T': apply Q' (Transpose)
+* = 'T': apply Q**T (Transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) DOUBLE PRECISION array, dimension (LDC,N)
* On entry, the m by n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'T', or
+* Q**T* C if SIDE = 'L' and TRANS = 'T', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'T',
+* C * Q**T if SIDE = 'R' and TRANS = 'T',
*
* where Q is a real orthogonal matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**T from the Left
+* = 'R': apply Q or Q**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'T': apply Q' (Transpose)
+* = 'T': apply Q**T (Transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) DOUBLE PRECISION array, dimension (LDC,N)
* On entry, the m by n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'T', or
+* Q**T* C if SIDE = 'L' and TRANS = 'T', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'T',
+* C * Q**T if SIDE = 'R' and TRANS = 'T',
*
* where Q is a real orthogonal matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**T from the Left
+* = 'R': apply Q or Q**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'T': apply Q' (Transpose)
+* = 'T': apply Q**T (Transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) DOUBLE PRECISION array, dimension (LDC,N)
* On entry, the m by n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
$ LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**T is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**T is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**T
*
CALL DLARFB( SIDE, TRANST, 'Forward', 'Rowwise', MI, NI, IB,
$ A( I, I ), LDA, T, LDT, C( IC, JC ), LDC, WORK,
$ A( 1, I ), LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(1:m-k+i+ib-1,1:n)
+* H or H**T is applied to C(1:m-k+i+ib-1,1:n)
*
MI = M - K + I + IB - 1
ELSE
*
-* H or H' is applied to C(1:m,1:n-k+i+ib-1)
+* H or H**T is applied to C(1:m,1:n-k+i+ib-1)
*
NI = N - K + I + IB - 1
END IF
*
-* Apply H or H'
+* Apply H or H**T
*
CALL DLARFB( SIDE, TRANS, 'Backward', 'Columnwise', MI, NI,
$ IB, A( 1, I ), LDA, T, LDT, C, LDC, WORK,
$ LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**T is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**T is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**T
*
CALL DLARFB( SIDE, TRANS, 'Forward', 'Columnwise', MI, NI,
$ IB, A( I, I ), LDA, T, LDT, C( IC, JC ), LDC,
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'T', or
+* Q**T* C if SIDE = 'L' and TRANS = 'T', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'T',
+* C * Q**T if SIDE = 'R' and TRANS = 'T',
*
* where Q is a real orthogonal matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**T from the Left
+* = 'R': apply Q or Q**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
*
* C (input/output) DOUBLE PRECISION array, dimension (LDC,N)
* On entry, the m by n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'T', or
+* Q**T* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'T',
+* C * Q**T if SIDE = 'R' and TRANS = 'C',
*
* where Q is a real orthogonal matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**T from the Left
+* = 'R': apply Q or Q**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'T': apply Q' (Transpose)
+* = 'T': apply Q**T (Transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) DOUBLE PRECISION array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(i:m,1:n)
+* H(i) or H(i)**T is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,i:n)
+* H(i) or H(i)**T is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**T
*
CALL DLARZ( SIDE, MI, NI, L, A( I, JA ), LDA, TAU( I ),
$ C( IC, JC ), LDC, WORK )
$ A( I, 1 ), LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(1:m-k+i+ib-1,1:n)
+* H or H**T is applied to C(1:m-k+i+ib-1,1:n)
*
MI = M - K + I + IB - 1
ELSE
*
-* H or H' is applied to C(1:m,1:n-k+i+ib-1)
+* H or H**T is applied to C(1:m,1:n-k+i+ib-1)
*
NI = N - K + I + IB - 1
END IF
*
-* Apply H or H'
+* Apply H or H**T
*
CALL DLARFB( SIDE, TRANST, 'Backward', 'Rowwise', MI, NI,
$ IB, A( I, 1 ), LDA, T, LDT, C, LDC, WORK,
*
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**T is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**T is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**T
*
CALL DLARZB( SIDE, TRANST, 'Backward', 'Rowwise', MI, NI,
$ IB, L, A( I, JA ), LDA, T, LDT, C( IC, JC ),
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**T).
*
CALL DLATBS( 'Upper', 'Transpose', 'Non-unit', NORMIN, N,
$ KD, AB, LDAB, WORK, SCALEL, WORK( 2*N+1 ),
$ INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**T).
*
CALL DLATBS( 'Lower', 'Transpose', 'Non-unit', NORMIN, N,
$ KD, AB, LDAB, WORK, SCALEU, WORK( 2*N+1 ),
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T*U or A = L*L**T.
*
CALL DPBTRF( UPLO, N, KD, AB, LDAB, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T *U or A = L*L**T.
*
IF( UPPER ) THEN
DO 40 J = 1, N
* positive definite band matrix A.
*
* The factorization has the form
-* A = U' * U , if UPLO = 'U', or
-* A = L * L', if UPLO = 'L',
-* where U is an upper triangular matrix, U' is the transpose of U, and
+* A = U**T * U , if UPLO = 'U', or
+* A = L * L**T, if UPLO = 'L',
+* where U is an upper triangular matrix, U**T is the transpose of U, and
* L is lower triangular.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
*
* On exit, if INFO = 0, the triangular factor U or L from the
-* Cholesky factorization A = U'*U or A = L*L' of the band
+* Cholesky factorization A = U**T*U or A = L*L**T of the band
* matrix A, in the same storage format as A.
*
* LDAB (input) INTEGER
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**T*U.
*
DO 10 J = 1, N
*
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**T.
*
DO 20 J = 1, N
*
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**T *U.
*
DO 10 J = 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, KD, AB,
$ LDAB, B( 1, J ), 1 )
10 CONTINUE
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L*L**T.
*
DO 20 J = 1, NRHS
*
CALL DTBSV( 'Lower', 'No transpose', 'Non-unit', N, KD, AB,
$ LDAB, B( 1, J ), 1 )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**T *X = B, overwriting B with X.
*
CALL DTBSV( 'Lower', 'Transpose', 'Non-unit', N, KD, AB,
$ LDAB, B( 1, J ), 1 )
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**T).
*
CALL DLATRS( 'Upper', 'Transpose', 'Non-unit', NORMIN, N, A,
$ LDA, WORK, SCALEL, WORK( 2*N+1 ), INFO )
$ A, LDA, WORK, SCALEL, WORK( 2*N+1 ), INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**T).
*
CALL DLATRS( 'Lower', 'Transpose', 'Non-unit', NORMIN, N, A,
$ LDA, WORK, SCALEU, WORK( 2*N+1 ), INFO )
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T*U or A = L*L**T.
*
CALL DPOTRF( UPLO, N, A, LDA, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T *U or A = L*L**T.
*
CALL DLACPY( UPLO, N, N, A, LDA, AF, LDAF )
CALL DPOTRF( UPLO, N, AF, LDAF, INFO )
* positive definite matrix A.
*
* The factorization has the form
-* A = U' * U , if UPLO = 'U', or
-* A = L * L', if UPLO = 'L',
+* A = U**T * U , if UPLO = 'U', or
+* A = L * L**T, if UPLO = 'L',
* where U is an upper triangular matrix and L is lower triangular.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* triangular part of A is not referenced.
*
* On exit, if INFO = 0, the factor U or L from the Cholesky
-* factorization A = U'*U or A = L*L'.
+* factorization A = U**T *U or A = L*L**T.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**T *U.
*
DO 10 J = 1, N
*
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**T.
*
DO 20 J = 1, N
*
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**T*U.
*
DO 10 J = 1, N, NB
*
*
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**T.
*
DO 20 J = 1, N, NB
*
IF( INFO.GT.0 )
$ RETURN
*
-* Form inv(U)*inv(U)' or inv(L)'*inv(L).
+* Form inv(U) * inv(U)**T or inv(L)**T * inv(L).
*
CALL DLAUUM( UPLO, N, A, LDA, INFO )
*
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**T *U.
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**T *X = B, overwriting B with X.
*
CALL DTRSM( 'Left', 'Upper', 'Transpose', 'Non-unit', N, NRHS,
$ ONE, A, LDA, B, LDB )
$ NRHS, ONE, A, LDA, B, LDB )
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L*L**T.
*
* Solve L*X = B, overwriting B with X.
*
CALL DTRSM( 'Left', 'Lower', 'No transpose', 'Non-unit', N,
$ NRHS, ONE, A, LDA, B, LDB )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**T *X = B, overwriting B with X.
*
CALL DTRSM( 'Left', 'Lower', 'Transpose', 'Non-unit', N, NRHS,
$ ONE, A, LDA, B, LDB )
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**T).
*
CALL DLATPS( 'Upper', 'Transpose', 'Non-unit', NORMIN, N,
$ AP, WORK, SCALEL, WORK( 2*N+1 ), INFO )
$ AP, WORK, SCALEL, WORK( 2*N+1 ), INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**T).
*
CALL DLATPS( 'Lower', 'Transpose', 'Non-unit', NORMIN, N,
$ AP, WORK, SCALEU, WORK( 2*N+1 ), INFO )
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T*U or A = L*L**T.
*
CALL DPPTRF( UPLO, N, AP, INFO )
IF( INFO.EQ.0 ) THEN
* (N*(N+1)/2)
* If FACT = 'F', then AFP is an input argument and on entry
* contains the triangular factor U or L from the Cholesky
-* factorization A = U'*U or A = L*L', in the same storage
+* factorization A = U**T*U or A = L*L**T, in the same storage
* format as A. If EQUED .ne. 'N', then AFP is the factored
* form of the equilibrated matrix A.
*
* If FACT = 'N', then AFP is an output argument and on exit
* returns the triangular factor U or L from the Cholesky
-* factorization A = U'*U or A = L*L' of the original matrix A.
+* factorization A = U**T * U or A = L * L**T of the original
+* matrix A.
*
* If FACT = 'E', then AFP is an output argument and on exit
* returns the triangular factor U or L from the Cholesky
-* factorization A = U'*U or A = L*L' of the equilibrated
+* factorization A = U**T * U or A = L * L**T of the equilibrated
* matrix A (see the description of AP for the form of the
* equilibrated matrix).
*
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T * U or A = L * L**T.
*
CALL DCOPY( N*( N+1 ) / 2, AP, 1, AFP, 1 )
CALL DPPTRF( UPLO, N, AFP, INFO )
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**T*U.
*
JJ = 0
DO 10 J = 1, N
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**T.
*
JJ = 1
DO 20 J = 1, N
*
IF( UPPER ) THEN
*
-* Compute the product inv(U) * inv(U)'.
+* Compute the product inv(U) * inv(U)**T.
*
JJ = 0
DO 10 J = 1, N
*
ELSE
*
-* Compute the product inv(L)' * inv(L).
+* Compute the product inv(L)**T * inv(L).
*
JJ = 1
DO 20 J = 1, N
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**T * U.
*
DO 10 I = 1, NRHS
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**T *X = B, overwriting B with X.
*
CALL DTPSV( 'Upper', 'Transpose', 'Non-unit', N, AP,
$ B( 1, I ), 1 )
10 CONTINUE
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L * L**T.
*
DO 20 I = 1, NRHS
*
CALL DTPSV( 'Lower', 'No transpose', 'Non-unit', N, AP,
$ B( 1, I ), 1 )
*
-* Solve L'*X = Y, overwriting B with X.
+* Solve L**T *X = Y, overwriting B with X.
*
CALL DTPSV( 'Lower', 'Transpose', 'Non-unit', N, AP,
$ B( 1, I ), 1 )
* 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)'.
+* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**T.
*
* Solve M(L) * x = e.
*
WORK( I ) = ONE + WORK( I-1 )*ABS( E( I-1 ) )
20 CONTINUE
*
-* Solve D * M(L)' * x = b.
+* Solve D * M(L)**T * x = b.
*
WORK( N ) = WORK( N ) / D( N )
DO 30 I = N - 1, 1, -1
* 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)'.
+* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**T.
*
* Solve M(L) * x = e.
*
WORK( I ) = ONE + WORK( I-1 )*ABS( EF( I-1 ) )
60 CONTINUE
*
-* Solve D * M(L)' * x = b.
+* Solve D * M(L)**T * x = b.
*
WORK( N ) = WORK( N ) / DF( N )
DO 70 I = N - 1, 1, -1
RETURN
END IF
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**T (or U**T*D*U) factorization of A.
*
CALL DPTTRF( N, D, E, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**T (or U**T*D*U) factorization of A.
*
CALL DCOPY( N, D, 1, DF, 1 )
IF( N.GT.1 )
* Purpose
* =======
*
-* DPTTRF computes the L*D*L' factorization of a real symmetric
+* DPTTRF computes the L*D*L**T factorization of a real symmetric
* positive definite tridiagonal matrix A. The factorization may also
-* be regarded as having the form A = U'*D*U.
+* be regarded as having the form A = U**T*D*U.
*
* Arguments
* =========
* D (input/output) DOUBLE PRECISION array, dimension (N)
* On entry, the n diagonal elements of the tridiagonal matrix
* A. On exit, the n diagonal elements of the diagonal matrix
-* D from the L*D*L' factorization of A.
+* D from the L*D*L**T factorization of A.
*
* E (input/output) DOUBLE PRECISION array, dimension (N-1)
* On entry, the (n-1) subdiagonal elements of the tridiagonal
* matrix A. On exit, the (n-1) subdiagonal elements of the
-* unit bidiagonal factor L from the L*D*L' factorization of A.
+* unit bidiagonal factor L from the L*D*L**T factorization of A.
* E can also be regarded as the superdiagonal of the unit
-* bidiagonal factor U from the U'*D*U factorization of A.
+* bidiagonal factor U from the U**T*D*U factorization of A.
*
* INFO (output) INTEGER
* = 0: successful exit
IF( N.EQ.0 )
$ RETURN
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**T (or U**T*D*U) factorization of A.
*
I4 = MOD( N-1, 4 )
DO 10 I = 1, I4
*
* DPTTRS solves a tridiagonal system of the form
* A * X = B
-* using the L*D*L' factorization of A computed by DPTTRF. D is a
+* using the L*D*L**T factorization of A computed by DPTTRF. D is a
* diagonal matrix specified in the vector D, L is a unit bidiagonal
* matrix whose subdiagonal is specified in the vector E, and X and B
* are N by NRHS matrices.
*
* D (input) DOUBLE PRECISION array, dimension (N)
* The n diagonal elements of the diagonal matrix D from the
-* L*D*L' factorization of A.
+* L*D*L**T factorization of A.
*
* E (input) DOUBLE PRECISION array, dimension (N-1)
* The (n-1) subdiagonal elements of the unit bidiagonal factor
-* L from the L*D*L' factorization of A. E can also be regarded
+* L from the L*D*L**T factorization of A. E can also be regarded
* as the superdiagonal of the unit bidiagonal factor U from the
-* factorization A = U'*D*U.
+* factorization A = U**T*D*U.
*
* B (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS)
* On entry, the right hand side vectors B for the system of
*
* DPTTS2 solves a tridiagonal system of the form
* A * X = B
-* using the L*D*L' factorization of A computed by DPTTRF. D is a
+* using the L*D*L**T factorization of A computed by DPTTRF. D is a
* diagonal matrix specified in the vector D, L is a unit bidiagonal
* matrix whose subdiagonal is specified in the vector E, and X and B
* are N by NRHS matrices.
*
* D (input) DOUBLE PRECISION array, dimension (N)
* The n diagonal elements of the diagonal matrix D from the
-* L*D*L' factorization of A.
+* L*D*L**T factorization of A.
*
* E (input) DOUBLE PRECISION array, dimension (N-1)
* The (n-1) subdiagonal elements of the unit bidiagonal factor
-* L from the L*D*L' factorization of A. E can also be regarded
+* L from the L*D*L**T factorization of A. E can also be regarded
* as the superdiagonal of the unit bidiagonal factor U from the
-* factorization A = U'*D*U.
+* factorization A = U**T*D*U.
*
* B (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS)
* On entry, the right hand side vectors B for the system of
RETURN
END IF
*
-* Solve A * X = B using the factorization A = L*D*L',
+* Solve A * X = B using the factorization A = L*D*L**T,
* overwriting each right hand side vector with its solution.
*
DO 30 J = 1, NRHS
B( I, J ) = B( I, J ) - B( I-1, J )*E( I-1 )
10 CONTINUE
*
-* Solve D * L' * x = b.
+* Solve D * L**T * x = b.
*
B( N, J ) = B( N, J ) / D( N )
DO 20 I = N - 1, 1, -1
CALL DLACN2( N, WORK( N+1 ), WORK, IWORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**T) or inv(U*D*U**T).
*
CALL DSPTRS( UPLO, N, 1, AP, IPIV, WORK, N, INFO )
GO TO 30
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**T)*A*inv(U)
*
* J1 and JJ are the indices of A(1,j) and A(j,j)
*
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**T)
*
* KK and K1K1 are the indices of A(k,k) and A(k+1,k+1)
*
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**T
*
* K1 and KK are the indices of A(1,k) and A(k,k)
*
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**T *A*L
*
* JJ and J1J1 are the indices of A(j,j) and A(j+1,j+1)
*
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T*y
*
IF( UPPER ) THEN
TRANS = 'T'
END IF
WORK( 1 ) = LWMIN
IWORK( 1 ) = LIWMIN
-*
IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
INFO = -11
ELSE IF( LIWORK.LT.LIWMIN .AND. .NOT.LQUERY ) THEN
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T *y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T *y
*
IF( UPPER ) THEN
TRANS = 'T'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T*y
*
IF( UPPER ) THEN
TRANS = 'T'
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL DSPTRF( UPLO, N, AP, IPIV, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL DCOPY( N*( N+1 ) / 2, AP, 1, AFP, 1 )
CALL DSPTRF( UPLO, N, AFP, IPIV, INFO )
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in AP,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in AP,
I1 = N*( N-1 ) / 2 + 1
DO 10 I = N - 1, 1, -1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**T
* to annihilate A(1:i-1,i+1)
*
CALL DLARFG( I, AP( I1+I-1 ), AP( I1 ), 1, TAUI )
CALL DSPMV( UPLO, I, TAUI, AP, AP( I1 ), 1, ZERO, TAU,
$ 1 )
*
-* Compute w := y - 1/2 * tau * (y'*v) * v
+* Compute w := y - 1/2 * tau * (y**T *v) * v
*
ALPHA = -HALF*TAUI*DDOT( I, TAU, 1, AP( I1 ), 1 )
CALL DAXPY( I, ALPHA, AP( I1 ), 1, TAU, 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v'
+* A := A - v * w**T - w * v**T
*
CALL DSPR2( UPLO, I, -ONE, AP( I1 ), 1, TAU, 1, AP )
*
DO 20 I = 1, N - 1
I1I1 = II + N - I + 1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**T
* to annihilate A(i+2:n,i)
*
CALL DLARFG( N-I, AP( II+1 ), AP( II+2 ), 1, TAUI )
CALL DSPMV( UPLO, N-I, TAUI, AP( I1I1 ), AP( II+1 ), 1,
$ ZERO, TAU( I ), 1 )
*
-* Compute w := y - 1/2 * tau * (y'*v) * v
+* Compute w := y - 1/2 * tau * (y**T *v) * v
*
ALPHA = -HALF*TAUI*DDOT( N-I, TAU( I ), 1, AP( II+1 ),
$ 1 )
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'
+* A := A - v * w' - w * v**T
*
CALL DSPR2( UPLO, N-I, -ONE, AP( II+1 ), 1, TAU( I ), 1,
$ AP( I1I1 ) )
* 5-96 - Based on modifications by J. Lewis, Boeing Computer Services
* Company
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**T = A - W(k)*1/D(k)*W(k)**T
*
R1 = ONE / AP( KC+K-1 )
CALL DSPR( UPLO, K-1, -R1, AP( KC ), 1, AP )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**T
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**T
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**T = A - W(k)*(1/D(k))*W(k)**T
*
R1 = ONE / AP( KC )
CALL DSPR( UPLO, N-K, -R1, AP( KC+1 ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )'
-* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )'
+* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )**T
+* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )**T
+*
+* where L(k) and L(k+1) are the k-th and (k+1)-th
+* columns of L
*
D21 = AP( K+1+( K-1 )*( 2*N-K ) / 2 )
D11 = AP( K+1+K*( 2*N-K-1 ) / 2 ) / D21
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**T.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**T*X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**T(K)), where U(K) is the transformation
* stored in column K of A.
*
CALL DGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, AP( KC ),
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**T(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
CALL DGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, AP( KC ),
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**T.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**T*X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**T(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N )
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**T(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
CALL DLACN2( N, WORK( N+1 ), WORK, IWORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**T) or inv(U*D*U**T).
*
CALL DSYTRS( UPLO, N, 1, A, LDA, IPIV, WORK, N, INFO )
GO TO 30
* to standard form.
*
* If ITYPE = 1, the problem is A*x = lambda*B*x,
-* and A is overwritten by inv(U')*A*inv(U) or inv(L)*A*inv(L')
+* and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T)
*
* If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or
-* B*A*x = lambda*x, and A is overwritten by U*A*U` or L'*A*L.
+* B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T *A*L.
*
-* B must have been previously factorized as U'*U or L*L' by DPOTRF.
+* B must have been previously factorized as U**T *U or L*L**T by DPOTRF.
*
* Arguments
* =========
*
* ITYPE (input) INTEGER
-* = 1: compute inv(U')*A*inv(U) or inv(L)*A*inv(L');
-* = 2 or 3: compute U*A*U' or L'*A*L.
+* = 1: compute inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T);
+* = 2 or 3: compute U*A*U**T or L**T *A*L.
*
* UPLO (input) CHARACTER*1
* Specifies whether the upper or lower triangular part of the
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**T)*A*inv(U)
*
DO 10 K = 1, N
*
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**T)
*
DO 20 K = 1, N
*
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**T
*
DO 30 K = 1, N
*
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**T *A*L
*
DO 40 K = 1, N
*
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**T)*A*inv(U)
*
DO 10 K = 1, N, NB
KB = MIN( N-K+1, NB )
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**T)
*
DO 20 K = 1, N, NB
KB = MIN( N-K+1, NB )
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**T
*
DO 30 K = 1, N, NB
KB = MIN( N-K+1, NB )
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**T*A*L
*
DO 40 K = 1, N, NB
KB = MIN( N-K+1, NB )
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T*y
*
IF( UPPER ) THEN
TRANS = 'T'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T*y
*
IF( UPPER ) THEN
TRANS = 'T'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T*y
*
IF( UPPER ) THEN
TRANS = 'T'
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL DSYTRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL DLACPY( UPLO, N, N, A, LDA, AF, LDAF )
CALL DSYTRF( UPLO, N, AF, LDAF, IPIV, WORK, LWORK, INFO )
* =======
*
* DSYTD2 reduces a real symmetric matrix A to symmetric tridiagonal
-* form T by an orthogonal similarity transformation: Q' * A * Q = T.
+* form T by an orthogonal similarity transformation: Q**T * A * Q = T.
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i),
*
DO 10 I = N - 1, 1, -1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**T
* to annihilate A(1:i-1,i+1)
*
CALL DLARFG( I, A( I, I+1 ), A( 1, I+1 ), 1, TAUI )
CALL DSYMV( UPLO, I, TAUI, A, LDA, A( 1, I+1 ), 1, ZERO,
$ TAU, 1 )
*
-* Compute w := x - 1/2 * tau * (x'*v) * v
+* Compute w := x - 1/2 * tau * (x**T * v) * v
*
ALPHA = -HALF*TAUI*DDOT( I, TAU, 1, A( 1, I+1 ), 1 )
CALL DAXPY( I, ALPHA, A( 1, I+1 ), 1, TAU, 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v'
+* A := A - v * w**T - w * v**T
*
CALL DSYR2( UPLO, I, -ONE, A( 1, I+1 ), 1, TAU, 1, A,
$ LDA )
*
DO 20 I = 1, N - 1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**T
* to annihilate A(i+2:n,i)
*
CALL DLARFG( N-I, A( I+1, I ), A( MIN( I+2, N ), I ), 1,
CALL DSYMV( UPLO, N-I, TAUI, A( I+1, I+1 ), LDA,
$ A( I+1, I ), 1, ZERO, TAU( I ), 1 )
*
-* Compute w := x - 1/2 * tau * (x'*v) * v
+* Compute w := x - 1/2 * tau * (x**T * v) * v
*
ALPHA = -HALF*TAUI*DDOT( N-I, TAU( I ), 1, A( I+1, I ),
$ 1 )
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'
+* A := A - v * w' - w * v**T
*
CALL DSYR2( UPLO, N-I, -ONE, A( I+1, I ), 1, TAU( I ), 1,
$ A( I+1, I+1 ), LDA )
* DSYTF2 computes the factorization of a real symmetric matrix A using
* the Bunch-Kaufman diagonal pivoting method:
*
-* A = U*D*U' or A = L*D*L'
+* A = U*D*U**T or A = L*D*L**T
*
* where U (or L) is a product of permutation and unit upper (lower)
-* triangular matrices, U' is the transpose of U, and D is symmetric and
+* triangular matrices, U**T is the transpose of U, and D is symmetric and
* block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* 1-96 - Based on modifications by J. Lewis, Boeing Computer Services
* Company
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**T = A - W(k)*1/D(k)*W(k)**T
*
R1 = ONE / A( K, K )
CALL DSYR( UPLO, K-1, -R1, A( 1, K ), 1, A, LDA )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**T
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**T
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**T = A - W(k)*(1/D(k))*W(k)**T
*
D11 = ONE / A( K, K )
CALL DSYR( UPLO, N-K, -D11, A( K+1, K ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( (A(k) A(k+1))*D(k)**(-1) ) * (A(k) A(k+1))'
+* A := A - ( (A(k) A(k+1))*D(k)**(-1) ) * (A(k) A(k+1))**T
*
* where L(k) and L(k+1) are the k-th and (k+1)-th
* columns of L
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i),
$ LDWORK )
*
* Update the unreduced submatrix A(1:i-1,1:i-1), using an
-* update of the form: A := A - V*W' - W*V'
+* update of the form: A := A - V*W' - 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'
+* an update of the form: A := A - V*W' - W*V**T
*
CALL DSYR2K( UPLO, 'No transpose', N-I-NB+1, NB, -ONE,
$ A( I+NB, I ), LDA, WORK( NB+1 ), LDWORK, ONE,
* Further Details
* ===============
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* KB, where KB is the number of columns factorized by DLASYF;
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* KB, where KB is the number of columns factorized by DLASYF;
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
IF( UPPER ) THEN
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
*
CALL DTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**T) = (inv(U))**T
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**T)*inv(D)*inv(U)
*
CUT=N
DO WHILE (CUT .GT. 0)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
*
CALL DTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**T) = (inv(U))**T
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**T)*inv(D)*inv(U)
*
CUT=0
DO WHILE (CUT .LT. N)
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
*
I=N
DO WHILE ( I .GE. 1 )
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**T.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**T *X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**T(K)), where U(K) is the transformation
* stored in column K of A.
*
CALL DGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, A( 1, K ),
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**T(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
CALL DGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, A( 1, K ),
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**T.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**T *X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**T(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N )
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**T(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* 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
END IF
END DO
*
-* Compute (U \P' * B) -> B [ (U \P' * B) ]
+* Compute (U \P**T * B) -> B [ (U \P**T * B) ]
*
CALL DTRSM('L','U','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (U \P' * B) ]
+* Compute D \ B -> B [ D \ (U \P**T * B) ]
*
I=N
DO WHILE ( I .GE. 1 )
I = I - 1
END DO
*
-* Compute (U' \ B) -> B [ U' \ (D \ (U \P' * B) ) ]
+* Compute (U**T \ B) -> B [ U**T \ (D \ (U \P**T * B) ) ]
*
CALL DTRSM('L','U','T','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (U' \ (D \ (U \P' * B) )) ]
+* P * B [ P * (U**T \ (D \ (U \P**T * B) )) ]
*
K=1
DO WHILE ( K .LE. N )
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* 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
ENDIF
END DO
*
-* Compute (L \P' * B) -> B [ (L \P' * B) ]
+* Compute (L \P**T * B) -> B [ (L \P**T * B) ]
*
CALL DTRSM('L','L','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (L \P' * B) ]
+* Compute D \ B -> B [ D \ (L \P**T * B) ]
*
I=1
DO WHILE ( I .LE. N )
I = I + 1
END DO
*
-* Compute (L' \ B) -> B [ L' \ (D \ (L \P' * B) ) ]
+* Compute (L**T \ B) -> B [ L**T \ (D \ (L \P**T * B) ) ]
*
CALL DTRSM('L','L','T','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (L' \ (D \ (L \P' * B) )) ]
+* P * B [ P * (L**T \ (D \ (L \P**T * B) )) ]
*
K=N
DO WHILE ( K .GE. 1 )
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(op(A)').
+* Multiply by diag(W)*inv(op(A)**T).
*
CALL DTBSV( UPLO, TRANST, DIAG, N, KD, AB, LDAB,
$ WORK( N+1 ), 1 )
* Optionally, the matrices Q and Z of generalized Schur vectors are
* updated.
*
-* Q(in) * A(in) * Z(in)' = Q(out) * A(out) * Z(out)'
-* Q(in) * B(in) * Z(in)' = Q(out) * B(out) * Z(out)'
+* Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T
+* Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T
*
*
* Arguments
IF( WANDS ) THEN
*
* Strong stability test:
-* F-norm((A-QL'*S*QR, B-QL'*T*QR)) <= O(EPS*F-norm((A,B)))
+* F-norm((A-QL**T*S*QR, B-QL**T*T*QR)) <= O(EPS*F-norm((A,B)))
*
CALL DLACPY( 'Full', M, M, A( J1, J1 ), LDA, WORK( M*M+1 ),
$ M )
*
* Compute orthogonal matrix QL:
*
-* QL' * LI = [ TL ]
-* [ 0 ]
+* QL**T * LI = [ TL ]
+* [ 0 ]
* where
* LI = [ -L ]
* [ SCALE * identity(N2) ]
*
* Compute orthogonal matrix RQ:
*
-* IR * RQ' = [ 0 TR],
+* IR * RQ**T = [ 0 TR],
*
* where IR = [ SCALE * identity(N1), R ]
*
IF( WANDS ) THEN
*
* Strong stability test:
-* F-norm((A-QL*S*QR', B-QL*T*QR')) <= O(EPS*F-norm((A,B)))
+* F-norm((A-QL*S*QR**T, B-QL*T*QR**T)) <= O(EPS*F-norm((A,B)))
*
CALL DLACPY( 'Full', M, M, A( J1, J1 ), LDA, WORK( M*M+1 ),
$ M )
* Optionally, the matrices Q and Z of generalized Schur vectors are
* updated.
*
-* Q(in) * A(in) * Z(in)' = Q(out) * A(out) * Z(out)'
-* Q(in) * B(in) * Z(in)' = Q(out) * B(out) * Z(out)'
+* Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T
+* Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T
*
*
* Arguments
*
* DTGSEN reorders the generalized real Schur decomposition of a real
* matrix pair (A, B) (in terms of an orthonormal equivalence trans-
-* formation Q' * (A, B) * Z), so that a selected cluster of eigenvalues
+* formation Q**T * (A, B) * Z), so that a selected cluster of eigenvalues
* appears in the leading diagonal blocks of the upper quasi-triangular
* matrix A and the upper triangular B. The leading columns of Q and
* Z form orthonormal bases of the corresponding left and right eigen-
* In other words, the selected eigenvalues are the eigenvalues of
* (A11, B11) in:
*
-* U'*(A, B)*W = (A11 A12) (B11 B12) n1
+* U**T*(A, B)*W = (A11 A12) (B11 B12) n1
* ( 0 A22),( 0 B22) n2
* n1 n2 n1 n2
*
* (deflating subspaces) of (A, B).
*
* If (A, B) has been obtained from the generalized real Schur
-* decomposition of a matrix pair (C, D) = Q*(A, B)*Z', then the
+* decomposition of a matrix pair (C, D) = Q*(A, B)*Z**T, then the
* reordered generalized real Schur form of (C, D) is given by
*
-* (C, D) = (Q*U)*(U'*(A, B)*W)*(Z*W)',
+* (C, D) = (Q*U)*(U**T*(A, B)*W)*(Z*W)**T,
*
* and the first n1 columns of Q*U and Z*W span the corresponding
* deflating subspaces of (C, D) (Q and Z store Q*U and Z*W, resp.).
* 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**T, In1) ]
+* [ kron(In2, B11) -kron(B22**T, In1) ].
*
-* Here, Inx is the identity matrix of size nx and A22' is the
+* Here, Inx is the identity matrix of size nx and A22**T is the
* transpose of A22. kron(X, Y) is the Kronecker product between
* the matrices X and Y.
*
*
* On exit,
*
-* U'*A*Q = D1*( 0 R ), V'*B*Q = D2*( 0 R ),
+* U**T *A*Q = D1*( 0 R ), V**T *B*Q = D2*( 0 R ),
*
-* where U, V and Q are orthogonal matrices, Z' denotes the transpose
-* of Z, R is a nonsingular upper triangular matrix, and D1 and D2 are
+* where U, V and Q are orthogonal matrices.
+* R is a nonsingular upper triangular matrix, and D1 and D2 are
* ``diagonal'' matrices, which are of the following structures:
*
* If M-K-L >= 0,
* min(L,M-K)-by-L triangular (or trapezoidal) matrix A23 and L-by-L
* matrix B13 to the form:
*
-* U1'*A13*Q1 = C1*R1; V1'*B13*Q1 = S1*R1,
+* 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
* of Z. C1 and S1 are diagonal matrices satisfying
CALL DLAGS2( UPPER, A1, A2, A3, B1, B2, B3, CSU, SNU,
$ CSV, SNV, CSQ, SNQ )
*
-* Update (K+I)-th and (K+J)-th rows of matrix A: U'*A
+* Update (K+I)-th and (K+J)-th rows of matrix A: U**T *A
*
IF( K+J.LE.M )
$ CALL DROT( L, A( K+J, N-L+1 ), LDA, A( K+I, N-L+1 ),
$ LDA, CSU, SNU )
*
-* Update I-th and J-th rows of matrix B: V'*B
+* Update I-th and J-th rows of matrix B: V**T *B
*
CALL DROT( L, B( J, N-L+1 ), LDB, B( I, N-L+1 ), LDB,
$ CSV, SNV )
* DTGSNA estimates reciprocal condition numbers for specified
* eigenvalues and/or eigenvectors of a matrix pair (A, B) in
* generalized real Schur canonical form (or of any matrix pair
-* (Q*A*Z', Q*B*Z') with orthogonal matrices Q and Z, where
+* (Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where
* Z' denotes the transpose of Z.
*
* (A, B) must be in generalized real Schur form (as returned by DGGES),
* The reciprocal of the condition number of a generalized eigenvalue
* w = (a, b) is defined as
*
-* S(w) = (|u'Av|**2 + |u'Bv|**2)**(1/2) / (norm(u)*norm(v))
+* S(w) = (|u**TAv|**2 + |u**TBv|**2)**(1/2) / (norm(u)*norm(v))
*
* where u and v are the left and right eigenvectors of (A, B)
* corresponding to w; |z| denotes the absolute value of the complex
* number, and norm(u) denotes the 2-norm of the vector u.
-* The pair (a, b) corresponds to an eigenvalue w = a/b (= u'Av/u'Bv)
+* The pair (a, b) corresponds to an eigenvalue w = a/b (= u**TAv/u**TBv)
* of the matrix pair (A, B). If both a and b equal zero, then (A B) is
* singular and S(I) = -1 is returned.
*
*
* Suppose U and V are orthogonal transformations such that
*
-* U'*(A, B)*V = (S, T) = ( a * ) ( b * ) 1
+* U**T*(A, B)*V = (S, T) = ( a * ) ( b * ) 1
* ( 0 S22 ),( 0 T22 ) n-1
* 1 n-1 1 n-1
*
*
* Suppose U and V are orthogonal transformations such that
*
-* U'*(A, B)*V = (S, T) = ( S11 * ) ( T11 * ) 2
+* U**T*(A, B)*V = (S, T) = ( S11 * ) ( T11 * ) 2
* ( 0 S22 ),( 0 T22) n-2
* 2 n-2 2 n-2
*
* pair (w, conjg(w)). There exist unitary matrices U1 and V1 such
* that
*
-* U1'*S11*V1 = ( s11 s12 ) and U1'*T11*V1 = ( t11 t12 )
+* U1**T*S11*V1 = ( s11 s12 ) and U1**T*T11*V1 = ( t11 t12 )
* ( 0 s22 ) ( 0 t22 )
*
* where the generalized eigenvalues w = s11/t11 and
* [ t11 -t22 ],
*
* This is done by computing (using real arithmetic) the
-* roots of the characteristical polynomial det(Z1' * Z1 - lambda I),
-* where Z1' denotes the conjugate transpose of Z1 and det(X) denotes
+* roots of the characteristical polynomial det(Z1**T * Z1 - lambda I),
+* where Z1**T denotes the transpose of Z1 and det(X) denotes
* the determinant of X.
*
* and d2 is an upper bound on Difl((S11, T11), (S22, T22)), i.e. an
ELSE
*
* Solve (I, J) - subsystem
-* A(I, I)' * R(I, J) + D(I, I)' * L(J, J) = C(I, J)
+* A(I, I)**T * R(I, J) + D(I, I)**T * L(J, J) = C(I, J)
* R(I, I) * B(J, J) + L(I, J) * E(J, J) = -F(I, J)
* for I = 1, 2, ..., P, J = Q, Q - 1, ..., 1
*
* Here Ik is the identity matrix of size k and X' 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'*y = scale*b,
+* If TRANS = 'T', DTGSYL solves the transposed system Z**T*y = scale*b,
* 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 (TRANS = 'T') is used to compute an one-norm-based estimate
* of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D)
ELSE
*
* Solve transposed (I, J)-subsystem
-* A(I, I)' * R(I, J) + D(I, I)' * L(I, J) = C(I, J)
-* R(I, J) * B(J, J)' + L(I, J) * E(J, J)' = -F(I, J)
+* A(I, I)**T * R(I, J) + D(I, I)**T * L(I, J) = C(I, J)
+* R(I, J) * B(J, J)**T + L(I, J) * E(J, J)**T = -F(I, J)
* for I = 1,2,..., P; J = Q, Q-1,..., 1
*
SCALE = ONE
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(op(A)').
+* Multiply by diag(W)*inv(op(A)**T).
*
CALL DTPSV( UPLO, TRANST, DIAG, N, AP, WORK( N+1 ), 1 )
DO 220 I = 1, N
* The right eigenvector x and the left eigenvector y of T corresponding
* to an eigenvalue w are defined by:
*
-* T*x = w*x, (y**H)*T = w*(y**H)
+* T*x = w*x, (y**T)*T = w*(y**T)
*
-* where y**H denotes the conjugate transpose of y.
+* where y**T denotes the transpose of y.
* The eigenvalues are not input to this routine, but are read directly
* from the diagonal blocks of T.
*
160 CONTINUE
*
* Solve the quasi-triangular system:
-* (T(KI+1:N,KI+1:N) - WR)'*X = SCALE*WORK
+* (T(KI+1:N,KI+1:N) - WR)**T*X = SCALE*WORK
*
VMAX = ONE
VCRIT = BIGNUM
$ DDOT( J-KI-1, T( KI+1, J ), 1,
$ WORK( KI+1+N ), 1 )
*
-* Solve (T(J,J)-WR)'*X = WORK
+* Solve (T(J,J)-WR)**T*X = WORK
*
CALL DLALN2( .FALSE., 1, 1, SMIN, ONE, T( J, J ),
$ LDT, ONE, ONE, WORK( J+N ), N, WR,
* Complex left eigenvector.
*
* Initial solve:
-* ((T(KI,KI) T(KI,KI+1) )' - (WR - I* WI))*X = 0.
+* ((T(KI,KI) T(KI,KI+1) )**T - (WR - I* WI))*X = 0.
* ((T(KI+1,KI) T(KI+1,KI+1)) )
*
IF( ABS( T( KI, KI+1 ) ).GE.ABS( T( KI+1, KI ) ) ) THEN
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(op(A)').
+* Multiply by diag(W)*inv(op(A)**T).
*
CALL DTRSV( UPLO, TRANST, DIAG, N, A, LDA, WORK( N+1 ),
$ 1 )
* In other words, the selected eigenvalues are the eigenvalues of T11
* in:
*
-* Z'*T*Z = ( T11 T12 ) n1
+* Z**T * T * Z = ( T11 T12 ) n1
* ( 0 T22 ) n2
* n1 n2
*
* of Z span the specified invariant subspace of T.
*
* If T has been obtained from the real Schur factorization of a matrix
-* A = Q*T*Q', then the reordered real Schur factorization of A is given
-* by A = (Q*Z)*(Z'*T*Z)*(Q*Z)', and the first n1 columns of Q*Z span
+* A = Q*T*Q**T, then the reordered real Schur factorization of A is given
+* by A = (Q*Z)*(Z**T*T*Z)*(Q*Z)**T, and the first n1 columns of Q*Z span
* the corresponding invariant subspace of A.
*
* The reciprocal condition number of the average of the eigenvalues of
$ IERR )
ELSE
*
-* Solve T11'*R - R*T22' = scale*X.
+* Solve T11**T*R - R*T22**T = scale*X.
*
CALL DTRSYL( 'T', 'T', -1, N1, N2, T, LDT,
$ T( N1+1, N1+1 ), LDT, WORK, N1, SCALE,
* The reciprocal of the condition number of an eigenvalue lambda is
* defined as
*
-* S(lambda) = |v'*u| / (norm(u)*norm(v))
+* S(lambda) = |v**T*u| / (norm(u)*norm(v))
*
* where u and v are the right and left eigenvectors of T corresponding
-* to lambda; v' denotes the conjugate-transpose of v, and norm(u)
+* to lambda; v**T denotes the transpose of v, and norm(u)
* denotes the Euclidean norm. These reciprocal condition numbers always
* lie between zero (very badly conditioned) and one (very well
* conditioned). If n = 1, S(lambda) is defined to be 1.
*
* Form
*
-* C' = WORK(2:N,2:N) + i*[rwork(1) ..... rwork(n-1) ]
-* [ mu ]
-* [ .. ]
-* [ .. ]
-* [ mu ]
-* where C' is conjugate transpose of complex matrix C,
+* C**T = WORK(2:N,2:N) + i*[rwork(1) ..... rwork(n-1) ]
+* [ mu ]
+* [ .. ]
+* [ .. ]
+* [ mu ]
+* where C**T is transpose of matrix C,
* and RWORK is stored starting in the N+1-st column of
* WORK.
*
NN = 2*( N-1 )
END IF
*
-* Estimate norm(inv(C'))
+* Estimate norm(inv(C**T))
*
EST = ZERO
KASE = 0
IF( KASE.EQ.1 ) THEN
IF( N2.EQ.1 ) THEN
*
-* Real eigenvalue: solve C'*x = scale*c.
+* Real eigenvalue: solve C**T*x = scale*c.
*
CALL DLAQTR( .TRUE., .TRUE., N-1, WORK( 2, 2 ),
$ LDWORK, DUMMY, DUMM, SCALE,
ELSE
*
* Complex eigenvalue: solve
-* C'*(p+iq) = scale*(c+id) in real arithmetic.
+* C**T*(p+iq) = scale*(c+id) in real arithmetic.
*
CALL DLAQTR( .TRUE., .FALSE., N-1, WORK( 2, 2 ),
$ LDWORK, WORK( 1, N+1 ), MU, SCALE,
*
ELSE IF( .NOT.NOTRNA .AND. NOTRNB ) THEN
*
-* Solve A' *X + ISGN*X*B = scale*C.
+* Solve A**T *X + ISGN*X*B = scale*C.
*
* The (K,L)th block of X is determined starting from
* upper-left corner column by column by
*
-* A(K,K)'*X(K,L) + ISGN*X(K,L)*B(L,L) = C(K,L) - R(K,L)
+* A(K,K)**T*X(K,L) + ISGN*X(K,L)*B(L,L) = C(K,L) - R(K,L)
*
* Where
-* K-1 L-1
-* R(K,L) = SUM [A(I,K)'*X(I,L)] +ISGN*SUM [X(K,J)*B(J,L)]
-* I=1 J=1
+* K-1 L-1
+* R(K,L) = SUM [A(I,K)**T*X(I,L)] +ISGN*SUM [X(K,J)*B(J,L)]
+* I=1 J=1
*
* Start column loop (index = L)
* L1 (L2): column index of the first (last) row of X(K,L)
*
ELSE IF( .NOT.NOTRNA .AND. .NOT.NOTRNB ) THEN
*
-* Solve A'*X + ISGN*X*B' = scale*C.
+* Solve A**T*X + ISGN*X*B**T = scale*C.
*
* The (K,L)th block of X is determined starting from
* top-right corner column by column by
*
-* A(K,K)'*X(K,L) + ISGN*X(K,L)*B(L,L)' = C(K,L) - R(K,L)
+* A(K,K)**T*X(K,L) + ISGN*X(K,L)*B(L,L)**T = C(K,L) - R(K,L)
*
* Where
-* K-1 N
-* R(K,L) = SUM [A(I,K)'*X(I,L)] + ISGN*SUM [X(K,J)*B(L,J)'].
-* I=1 J=L+1
+* K-1 N
+* R(K,L) = SUM [A(I,K)**T*X(I,L)] + ISGN*SUM [X(K,J)*B(L,J)**T].
+* I=1 J=L+1
*
* Start column loop (index = L)
* L1 (L2): column index of the first (last) row of X(K,L)
*
ELSE IF( NOTRNA .AND. .NOT.NOTRNB ) THEN
*
-* Solve A*X + ISGN*X*B' = scale*C.
+* Solve A*X + ISGN*X*B**T = scale*C.
*
* The (K,L)th block of X is determined starting from
* bottom-right corner column by column by
*
-* A(K,K)*X(K,L) + ISGN*X(K,L)*B(L,L)' = C(K,L) - R(K,L)
+* A(K,K)*X(K,L) + ISGN*X(K,L)*B(L,L)**T = C(K,L) - R(K,L)
*
* Where
* M N
-* R(K,L) = SUM [A(K,I)*X(I,L)] + ISGN*SUM [X(K,J)*B(L,J)'].
+* R(K,L) = SUM [A(K,I)*X(I,L)] + ISGN*SUM [X(K,J)*B(L,J)**T].
* I=K+1 J=L+1
*
* Start column loop (index = L)
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
-* ( 0 )
-* ( z( k ) )
+* T( k ) = I - tau*u( k )*u( k )**T, u( k ) = ( 1 ),
+* ( 0 )
+* ( z( k ) )
*
* tau is a scalar and z( k ) is an ( n - m ) element vector.
* tau and z( k ) are chosen to annihilate the elements of the kth row
$ LDA, A( K, M1 ), LDA, ONE, TAU, 1 )
*
* Now form a( k ) := a( k ) - tau*w
-* and B := B - tau*w*z( k )'.
+* and B := B - tau*w*z( k )**T.
*
CALL DAXPY( K-1, -TAU( K ), TAU, 1, A( 1, K ), 1 )
CALL DGER( K-1, N-M, -TAU( K ), TAU, 1, A( K, M1 ), LDA,
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
+* T( k ) = I - tau*u( k )*u( k )**T, u( k ) = ( 1 ),
* ( 0 )
* ( z( k ) )
*
* =======
*
* SGBBRD reduces a real general m-by-n band matrix A to upper
-* bidiagonal form B by an orthogonal transformation: Q' * A * P = B.
+* bidiagonal form B by an orthogonal transformation: Q**T * A * P = B.
*
-* The routine computes B, and optionally forms Q or P', or computes
-* Q'*C for a given matrix C.
+* The routine computes B, and optionally forms Q or P**T, or computes
+* Q**T*C for a given matrix C.
*
* Arguments
* =========
*
* VECT (input) CHARACTER*1
-* Specifies whether or not the matrices Q and P' are to be
+* Specifies whether or not the matrices Q and P**T are to be
* formed.
-* = 'N': do not form Q or P';
+* = 'N': do not form Q or P**T;
* = 'Q': form Q only;
-* = 'P': form P' only;
+* = 'P': form P**T only;
* = 'B': form both.
*
* M (input) INTEGER
*
* C (input/output) REAL array, dimension (LDC,NCC)
* On entry, an m-by-ncc matrix C.
-* On exit, C is overwritten by Q'*C.
+* On exit, C is overwritten by Q**T*C.
* C is not referenced if NCC = 0.
*
* LDC (input) INTEGER
RETURN
END IF
*
-* Initialize Q and P' to the unit matrix, if needed
+* Initialize Q and P**T to the unit matrix, if needed
*
IF( WANTQ )
$ CALL SLASET( 'Full', M, M, ZERO, ONE, Q, LDQ )
*
IF( WANTPT ) THEN
*
-* accumulate product of plane rotations in P'
+* accumulate product of plane rotations in P**T
*
DO 60 J = J1, J2, KB1
CALL SROT( N, PT( J+KUN-1, 1 ), LDPT,
$ INFO )
ELSE
*
-* Multiply by inv(U').
+* Multiply by inv(U**T).
*
CALL SLATBS( 'Upper', 'Transpose', 'Non-unit', NORMIN, N,
$ KL+KU, AB, LDAB, WORK, SCALE, WORK( 2*N+1 ),
$ INFO )
*
-* Multiply by inv(L').
+* Multiply by inv(L**T).
*
IF( LNOTI ) THEN
DO 30 J = N - 1, 1, -1
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**T and G(i) = I - taup * u * u**T
*
* where tauq and taup are real scalars, and v and u are real vectors;
* v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in A(i+1:m,i);
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**T and G(i) = I - taup * u * u**T
*
* where tauq and taup are real scalars, and v and u are real vectors;
* v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in A(i+2:m,i);
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**T and G(i) = I - taup * u * u**T
*
* where tauq and taup are real scalars, and v and u are real vectors;
* v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in A(i+1:m,i);
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**T and G(i) = I - taup * u * u**T
*
* where tauq and taup are real scalars, and v and u are real vectors;
* v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in A(i+2:m,i);
$ WORK( LDWRKX*NB+1 ), LDWRKY )
*
* Update the trailing submatrix A(i+nb:m,i+nb:n), using an update
-* of the form A := A - V*Y' - X*U'
+* of the form A := A - V*Y**T - X*U**T
*
CALL SGEMM( 'No transpose', 'Transpose', M-I-NB+1, N-I-NB+1,
$ NB, -ONE, A( I+NB, I ), LDA,
$ A, LDA, WORK, SU, WORK( 3*N+1 ), INFO )
ELSE
*
-* Multiply by inv(U').
+* Multiply by inv(U**T).
*
CALL SLATRS( 'Upper', 'Transpose', 'Non-unit', NORMIN, N, A,
$ LDA, WORK, SU, WORK( 3*N+1 ), INFO )
*
-* Multiply by inv(L').
+* Multiply by inv(L**T).
*
CALL SLATRS( 'Lower', 'Transpose', 'Unit', NORMIN, N, A,
$ LDA, WORK, SL, WORK( 2*N+1 ), INFO )
* A * v(j) = lambda(j) * v(j)
* where lambda(j) is its eigenvalue.
* The left eigenvector u(j) of A satisfies
-* u(j)**H * A = lambda(j) * u(j)**H
-* where u(j)**H denotes the conjugate transpose of u(j).
+* u(j)**T * A = lambda(j) * u(j)**T
+* where u(j)**T denotes the transpose of u(j).
*
* The computed eigenvectors are normalized to have Euclidean norm
* equal to 1 and largest component real.
* A * v(j) = lambda(j) * v(j)
* where lambda(j) is its eigenvalue.
* The left eigenvector u(j) of A satisfies
-* u(j)**H * A = lambda(j) * u(j)**H
-* where u(j)**H denotes the conjugate transpose of u(j).
+* u(j)**T * A = lambda(j) * u(j)**T
+* where u(j)**T denotes the transpose of u(j).
*
* The computed eigenvectors are normalized to have Euclidean norm
* equal to 1 and largest component real.
* =======
*
* SGEHD2 reduces a real general matrix A to upper Hessenberg form H by
-* an orthogonal similarity transformation: Q' * A * Q = H .
+* an orthogonal similarity transformation: Q**T * A * Q = H .
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on
* =======
*
* SGEHRD reduces a real general matrix A to upper Hessenberg form H by
-* an orthogonal similarity transformation: Q' * A * Q = H .
+* an orthogonal similarity transformation: Q**T * A * Q = H .
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on
IB = MIN( NB, IHI-I )
*
* Reduce columns i:i+ib-1 to Hessenberg form, returning the
-* matrices V and T of the block reflector H = I - V*T*V'
+* matrices V and T of the block reflector H = I - V*T*V**T
* which performs the reduction, and also the matrix Y = A*V*T
*
CALL SLAHR2( IHI, I, IB, A( 1, I ), LDA, TAU( I ), T, LDT,
$ WORK, LDWORK )
*
* Apply the block reflector H to A(1:ihi,i+ib:ihi) from the
-* right, computing A := A - Y * V'. V(i+ib,ib-1) must be set
+* right, computing A := A - Y * V**T. V(i+ib,ib-1) must be set
* to 1
*
EI = A( I+IB, I+IB-1 )
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i,i+1:n),
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i,i+1:n),
*
* Least-Squares Problem min || A * X - B ||
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**T * B(1:M,1:NRHS)
*
CALL SORMQR( 'Left', 'Transpose', M, NRHS, N, A, LDA,
$ WORK( 1 ), B, LDB, WORK( MN+1 ), LWORK-MN,
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Q(1:N,:)' * B(1:M,1:NRHS)
+* B(1:N,1:NRHS) := Q(1:N,:)**T * B(1:M,1:NRHS)
*
CALL SORMLQ( 'Left', 'Transpose', N, NRHS, M, A, LDA,
$ WORK( 1 ), B, LDB, WORK( MN+1 ), LWORK-MN,
* 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**T [ inv(T11)*Q1**T*B ]
+* [ 0 ]
* where Q1 consists of the first RANK columns of Q.
*
* Arguments
*
* Details of Householder rotations stored in WORK(MN+1:2*MN)
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**T * B(1:M,1:NRHS)
*
CALL SORM2R( 'Left', 'Transpose', M, NRHS, MN, A, LDA, WORK( 1 ),
$ B, LDB, WORK( 2*MN+1 ), INFO )
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Y' * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := Y**T * B(1:N,1:NRHS)
*
IF( RANK.LT.N ) THEN
DO 50 I = 1, RANK
* 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**T [ inv(T11)*Q1**T*B ]
+* [ 0 ]
* where Q1 consists of the first RANK columns of Q.
*
* This routine is basically identical to the original xGELSX except
* workspace: 2*MN.
* Details of Householder rotations stored in WORK(MN+1:2*MN)
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**T * B(1:M,1:NRHS)
*
CALL SORMQR( 'Left', 'Transpose', M, NRHS, MN, A, LDA, WORK( 1 ),
$ B, LDB, WORK( 2*MN+1 ), LWORK-2*MN, INFO )
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Y' * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := Y**T * B(1:N,1:NRHS)
*
IF( RANK.LT.N ) THEN
CALL SORMRZ( 'Left', 'Transpose', N, NRHS, RANK, N-RANK, A,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in
CALL SLARFT( 'Backward', 'Columnwise', M-K+I+IB-1, IB,
$ A( 1, N-K+I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(1:m-k+i+ib-1,1:n-k+i-1) from the left
+* Apply H**T to A(1:m-k+i+ib-1,1:n-k+i-1) from the left
*
CALL SLARFB( 'Left', 'Transpose', 'Backward',
$ 'Columnwise', M-K+I+IB-1, N-K+I-1, IB,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real/complex scalar, and v is a real/complex vector
* with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in
*
* Each H(i) has the form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
CALL SLARFT( 'Forward', 'Columnwise', M-I+1, IB,
$ A( I, I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i:m,i+ib:n) from the left
+* Apply H**T to A(i:m,i+ib:n) from the left
*
CALL SLARFB( 'Left', 'Transpose', 'Forward',
$ 'Columnwise', M-I+1, N-I-IB+1, IB,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
CALL SLARFT( 'Forward', 'Columnwise', M-I+1, IB,
$ A( I, I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i:m,i+ib:n) from the left
+* Apply H**T to A(i:m,i+ib:n) from the left
*
CALL SLARFB( 'Left', 'Transpose', 'Forward',
$ 'Columnwise', M-I+1, N-I-IB+1, IB,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in
* =======
*
* SGETRS solves a system of linear equations
-* A * X = B or A' * X = B
+* A * X = B or A**T * X = B
* with a general N-by-N matrix A using the LU factorization computed
* by SGETRF.
*
* 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.
$ NRHS, ONE, A, LDA, B, LDB )
ELSE
*
-* Solve A' * X = B.
+* Solve A**T * X = B.
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**T *X = B, overwriting B with X.
*
CALL STRSM( 'Left', 'Upper', 'Transpose', 'Non-unit', N, NRHS,
$ ONE, A, LDA, B, LDB )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**T *X = B, overwriting B with X.
*
CALL STRSM( 'Left', 'Lower', 'Transpose', 'Unit', N, NRHS, ONE,
$ A, LDA, B, LDB )
*
* Compute the GQR factorization of matrices A and B:
*
-* Q'*A = ( R11 ) M, Q'*B*Z' = ( T11 T12 ) M
-* ( 0 ) N-M ( 0 T22 ) N-M
-* M M+P-N N-M
+* Q**T*A = ( R11 ) M, Q**T*B*Z**T = ( T11 T12 ) M
+* ( 0 ) N-M ( 0 T22 ) N-M
+* M M+P-N N-M
*
* where R11 and T22 are upper triangular, and Q and Z are
* orthogonal.
$ WORK( M+NP+1 ), LWORK-M-NP, INFO )
LOPT = WORK( M+NP+1 )
*
-* Update left-hand-side vector d = Q'*d = ( d1 ) M
-* ( d2 ) N-M
+* Update left-hand-side vector d = Q**T*d = ( d1 ) M
+* ( d2 ) N-M
*
CALL SORMQR( 'Left', 'Transpose', N, 1, M, A, LDA, WORK, D,
$ MAX( 1, N ), WORK( M+NP+1 ), LWORK-M-NP, INFO )
CALL SCOPY( M, D, 1, X, 1 )
END IF
*
-* Backward transformation y = Z'*y
+* Backward transformation y = Z**T *y
*
CALL SORMRQ( 'Left', 'Transpose', P, 1, NP,
$ B( MAX( 1, N-P+1 ), 1 ), LDB, WORK( M+1 ), Y,
*
* Compute the GRQ factorization of matrices B and A:
*
-* B*Q' = ( 0 T12 ) P Z'*A*Q' = ( R11 R12 ) N-P
-* N-P P ( 0 R22 ) M+P-N
-* N-P P
+* B*Q**T = ( 0 T12 ) P Z**T*A*Q**T = ( R11 R12 ) N-P
+* N-P P ( 0 R22 ) M+P-N
+* N-P P
*
* where T12 and R11 are upper triangular, and Q and Z are
* orthogonal.
$ WORK( P+MN+1 ), LWORK-P-MN, INFO )
LOPT = WORK( P+MN+1 )
*
-* Update c = Z'*c = ( c1 ) N-P
-* ( c2 ) M+P-N
+* Update c = Z**T *c = ( c1 ) N-P
+* ( c2 ) M+P-N
*
CALL SORMQR( 'Left', 'Transpose', M, 1, MN, A, LDA, WORK( P+1 ),
$ C, MAX( 1, M ), WORK( P+MN+1 ), LWORK-P-MN, INFO )
RETURN
END IF
*
-* Put the solution in X
+* Put the solutions in X
*
CALL SCOPY( N-P, C, 1, X, 1 )
END IF
CALL SAXPY( NR, -ONE, D, 1, C( N-P+1 ), 1 )
END IF
*
-* Backward transformation x = Q'*x
+* Backward transformation x = Q**T*x
*
CALL SORMRQ( 'Left', 'Transpose', N, 1, P, B, LDB, WORK( 1 ), X,
$ N, WORK( P+MN+1 ), LWORK-P-MN, INFO )
* In particular, if B is square and nonsingular, the GQR factorization
* of A and B implicitly gives the QR factorization of inv(B)*A:
*
-* inv(B)*A = Z'*(inv(T)*R)
+* inv(B)*A = Z**T*(inv(T)*R)
*
-* where inv(B) denotes the inverse of the matrix B, and Z' denotes the
+* where inv(B) denotes the inverse of the matrix B, and Z**T denotes the
* transpose of the matrix Z.
*
* Arguments
*
* Each H(i) has the form
*
-* H(i) = I - taua * v * v'
+* H(i) = I - taua * v * v**T
*
* where taua is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i+1:n,i),
*
* Each H(i) has the form
*
-* H(i) = I - taub * v * v'
+* H(i) = I - taub * v * v**T
*
* where taub is a real scalar, and v is a real vector with
* v(p-k+i+1:p) = 0 and v(p-k+i) = 1; v(1:p-k+i-1) is stored on exit in
CALL SGEQRF( N, M, A, LDA, TAUA, WORK, LWORK, INFO )
LOPT = WORK( 1 )
*
-* Update B := Q'*B.
+* Update B := Q**T*B.
*
CALL SORMQR( 'Left', 'Transpose', N, P, MIN( N, M ), A, LDA, TAUA,
$ B, LDB, WORK, LWORK, INFO )
* In particular, if B is square and nonsingular, the GRQ factorization
* of A and B implicitly gives the RQ factorization of A*inv(B):
*
-* A*inv(B) = (R*inv(T))*Z'
+* A*inv(B) = (R*inv(T))*Z**T
*
-* where inv(B) denotes the inverse of the matrix B, and Z' denotes the
+* where inv(B) denotes the inverse of the matrix B, and Z**T denotes the
* transpose of the matrix Z.
*
* Arguments
*
* Each H(i) has the form
*
-* H(i) = I - taua * v * v'
+* H(i) = I - taua * v * v**T
*
* where taua is a real scalar, and v is a real vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - taub * v * v'
+* H(i) = I - taub * v * v**T
*
* where taub is a real scalar, and v is a real vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:p) is stored on exit in B(i+1:p,i),
CALL SGERQF( M, N, A, LDA, TAUA, WORK, LWORK, INFO )
LOPT = WORK( 1 )
*
-* Update B := B*Q'
+* Update B := B*Q**T
*
CALL SORMRQ( 'Right', 'Transpose', P, N, MIN( M, N ),
$ A( MAX( 1, M-N+1 ), 1 ), LDA, TAUA, B, LDB, WORK,
* SGGSVD computes the generalized singular value decomposition (GSVD)
* of an M-by-N real matrix A and P-by-N real matrix B:
*
-* U'*A*Q = D1*( 0 R ), V'*B*Q = D2*( 0 R )
+* U**T*A*Q = D1*( 0 R ), V**T*B*Q = D2*( 0 R )
*
-* where U, V and Q are orthogonal matrices, and Z' is the transpose
-* of Z. Let K+L = the effective numerical rank of the matrix (A',B')',
+* where U, V and Q are orthogonal matrices.
+* Let K+L = the effective numerical rank of the matrix (A**T,B**T)**T,
* then R is a K+L-by-K+L nonsingular upper triangular matrix, D1 and
* D2 are M-by-(K+L) and P-by-(K+L) "diagonal" matrices and of the
* following structures, respectively:
*
* In particular, if B is an N-by-N nonsingular matrix, then the GSVD of
* A and B implicitly gives the SVD of A*inv(B):
-* A*inv(B) = U*(D1*inv(D2))*V'.
-* If ( A',B')' has orthonormal columns, then the GSVD of A and B is
+* A*inv(B) = U*(D1*inv(D2))*V**T.
+* If ( A**T,B**T)**T has orthonormal columns, then the GSVD of A and B is
* also equal to the CS decomposition of A and B. Furthermore, the GSVD
* can be used to derive the solution of the eigenvalue problem:
-* A'*A x = lambda* B'*B x.
+* A**T*A x = lambda* B**T*B x.
* In some literature, the GSVD of A and B is presented in the form
-* U'*A*X = ( 0 D1 ), V'*B*X = ( 0 D2 )
+* U**T*A*X = ( 0 D1 ), V**T*B*X = ( 0 D2 )
* where U and V are orthogonal and X is nonsingular, D1 and D2 are
* ``diagonal''. The former GSVD form can be converted to the latter
* form by taking the nonsingular matrix X as
* 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')'.
+* K + L = effective numerical rank of (A',B')**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')'. Generally, they are set to
+* rank of (A',B')**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
*
* SGGSVP computes orthogonal matrices U, V and Q such that
*
-* N-K-L K L
-* U'*A*Q = K ( 0 A12 A13 ) if M-K-L >= 0;
-* L ( 0 0 A23 )
-* M-K-L ( 0 0 0 )
+* N-K-L K L
+* U**T*A*Q = K ( 0 A12 A13 ) if M-K-L >= 0;
+* L ( 0 0 A23 )
+* M-K-L ( 0 0 0 )
*
* N-K-L K L
* = K ( 0 A12 A13 ) if M-K-L < 0;
* M-K ( 0 0 A23 )
*
-* N-K-L K L
-* V'*B*Q = L ( 0 0 B13 )
-* P-L ( 0 0 0 )
+* N-K-L K L
+* V**T*B*Q = L ( 0 0 B13 )
+* P-L ( 0 0 0 )
*
* where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular
* upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,
* otherwise A23 is (M-K)-by-L upper trapezoidal. K+L = the effective
-* numerical rank of the (M+P)-by-N matrix (A',B')'. Z' denotes the
-* transpose of Z.
+* numerical rank of the (M+P)-by-N matrix (A**T,B**T)**T.
*
* This decomposition is the preprocessing step for computing the
* Generalized Singular Value Decomposition (GSVD), see subroutine
* K (output) INTEGER
* L (output) INTEGER
* On exit, K and L specify the dimension of the subblocks
-* described in Purpose.
-* K + L = effective numerical rank of (A',B')'.
+* described in Purpose section.
+* K + L = effective numerical rank of (A**T,B**T)**T.
*
* U (output) REAL array, dimension (LDU,M)
* If JOBU = 'U', U contains the orthogonal matrix U.
*
CALL SGERQ2( L, N, B, LDB, TAU, WORK, INFO )
*
-* Update A := A*Z'
+* Update A := A*Z**T
*
CALL SORMR2( 'Right', 'Transpose', M, N, L, B, LDB, TAU, A,
$ LDA, WORK, INFO )
*
IF( WANTQ ) THEN
*
-* Update Q := Q*Z'
+* Update Q := Q*Z**T
*
CALL SORMR2( 'Right', 'Transpose', N, N, L, B, LDB, TAU, Q,
$ LDQ, WORK, INFO )
*
* then the following does the complete QR decomposition of A11:
*
-* A11 = U*( 0 T12 )*P1'
+* A11 = U*( 0 T12 )*P1**T
* ( 0 0 )
*
DO 70 I = 1, N - L
$ K = K + 1
80 CONTINUE
*
-* Update A12 := U'*A12, where A12 = A( 1:M, N-L+1:N )
+* Update A12 := U**T*A12, where A12 = A( 1:M, N-L+1:N )
*
CALL SORM2R( 'Left', 'Transpose', M, L, MIN( M, N-L ), A, LDA,
$ TAU, A( 1, N-L+1 ), LDA, WORK, INFO )
*
IF( WANTQ ) THEN
*
-* Update Q( 1:N,1:N-L ) = Q( 1:N,1:N-L )*Z1'
+* Update Q( 1:N,1:N-L ) = Q( 1:N,1:N-L )*Z1**T
*
CALL SORMR2( 'Right', 'Transpose', N, N-L, K, A, LDA, TAU,
$ Q, LDQ, WORK, INFO )
$ WORK, N, INFO )
ELSE
*
-* Multiply by inv(L')*inv(U').
+* Multiply by inv(L**T)*inv(U**T).
*
CALL SGTTRS( 'Transpose', N, 1, DL, D, DU, DU2, IPIV, WORK,
$ N, INFO )
* where A is an n by n tridiagonal matrix, by Gaussian elimination with
* partial pivoting.
*
-* Note that the equation A'*X = B may be solved by interchanging the
+* Note that the equation A**T*X = B may be solved by interchanging the
* order of the arguments DU and DL.
*
* Arguments
* SLA_GBAMV performs one of the matrix-vector operations
*
* y := alpha*abs(A)*abs(x) + beta*abs(y),
-* or y := alpha*abs(A)'*abs(x) + beta*abs(y),
+* or y := alpha*abs(A)**T*abs(x) + beta*abs(y),
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
* follows:
*
* BLAS_NO_TRANS y := alpha*abs(A)*abs(x) + beta*abs(y)
-* BLAS_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
-* BLAS_CONJ_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
+* BLAS_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
+* BLAS_CONJ_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
*
* Unchanged on exit.
*
-* M (input) INTEGER
+* M (input) INTEGER
* On entry, M specifies the number of rows of the matrix A.
* M must be at least zero.
* Unchanged on exit.
*
-* N (input) INTEGER
+* N (input) INTEGER
* On entry, N specifies the number of columns of the matrix A.
* N must be at least zero.
* Unchanged on exit.
*
-* KL (input) INTEGER
+* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
-* KU (input) INTEGER
+* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
-* ALPHA (input) REAL
+* ALPHA (input) REAL
* On entry, ALPHA specifies the scalar alpha.
* Unchanged on exit.
*
-* A - REAL array of DIMENSION ( LDA, n )
-* Before entry, the leading m by n part of the array A must
+* AB (input) REAL array of DIMENSION ( LDAB, n )
+* Before entry, the leading m by n part of the array AB must
* contain the matrix of coefficients.
* Unchanged on exit.
*
-* LDA (input) INTEGER
-* On entry, LDA specifies the first dimension of A as declared
-* in the calling (sub) program. LDA must be at least
+* LDAB (input) INTEGER
+* On entry, LDA specifies the first dimension of AB as declared
+* in the calling (sub) program. LDAB must be at least
* max( 1, m ).
* Unchanged on exit.
*
-* X (input) REAL array, dimension
+* X (input) REAL array, dimension
* ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
* vector x.
* Unchanged on exit.
*
-* INCX (input) INTEGER
+* INCX (input) INTEGER
* On entry, INCX specifies the increment for the elements of
* X. INCX must not be zero.
* Unchanged on exit.
*
-* BETA (input) REAL
+* BETA (input) REAL
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input.
* Unchanged on exit.
*
-* Y (input/output) REAL array, dimension
+* Y (input/output) REAL array, dimension
* ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
* must contain the vector y. On exit, Y is overwritten by the
* updated vector y.
*
-* INCY (input) INTEGER
+* INCY (input) INTEGER
* On entry, INCY specifies the increment for the elements of
* Y. INCY must not be zero.
* Unchanged on exit.
* SLA_GEAMV performs one of the matrix-vector operations
*
* y := alpha*abs(A)*abs(x) + beta*abs(y),
-* or y := alpha*abs(A)'*abs(x) + beta*abs(y),
+* or y := alpha*abs(A)**T*abs(x) + beta*abs(y),
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
* follows:
*
* BLAS_NO_TRANS y := alpha*abs(A)*abs(x) + beta*abs(y)
-* BLAS_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
-* BLAS_CONJ_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
+* BLAS_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
+* BLAS_CONJ_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
*
* Unchanged on exit.
*
-* M (input) INTEGER
+* M (input) INTEGER
* On entry, M specifies the number of rows of the matrix A.
* M must be at least zero.
* Unchanged on exit.
*
-* N (input) INTEGER
+* N (input) INTEGER
* On entry, N specifies the number of columns of the matrix A.
* N must be at least zero.
* Unchanged on exit.
*
-* ALPHA (input) REAL
+* ALPHA (input) REAL
* On entry, ALPHA specifies the scalar alpha.
* Unchanged on exit.
*
-* A - REAL array of DIMENSION ( LDA, n )
+* A (input) REAL array of DIMENSION ( LDA, n )
* Before entry, the leading m by n part of the array A must
* contain the matrix of coefficients.
* Unchanged on exit.
*
-* LDA (input) INTEGER
+* LDA (input) INTEGER
* On entry, LDA specifies the first dimension of A as declared
* in the calling (sub) program. LDA must be at least
* max( 1, m ).
* Unchanged on exit.
*
-* X (input) REAL array, dimension
+* X (input) REAL array, dimension
* ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
* vector x.
* Unchanged on exit.
*
-* INCX (input) INTEGER
+* INCX (input) INTEGER
* On entry, INCX specifies the increment for the elements of
* X. INCX must not be zero.
* Unchanged on exit.
*
-* BETA (input) REAL
+* BETA (input) REAL
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input.
* Unchanged on exit.
*
-* Y - REAL
+* Y (input/output) REAL
* Array of DIMENSION at least
* ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
* and at least
* must contain the vector y. On exit, Y is overwritten by the
* updated vector y.
*
-* INCY (input) INTEGER
+* INCY (input) INTEGER
* On entry, INCY specifies the increment for the elements of
* Y. INCY must not be zero.
* Unchanged on exit.
*
* SLABRD reduces the first NB rows and columns of a real general
* m by n matrix A to upper or lower bidiagonal form by an orthogonal
-* transformation Q' * A * P, and returns the matrices X and Y which
+* transformation Q**T * A * P, and returns the matrices X and Y which
* are needed to apply the transformation to the unreduced part of A.
*
* If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower
* of A.
*
* LDX (input) INTEGER
-* The leading dimension of the array X. LDX >= M.
+* The leading dimension of the array X. LDX >= max(1,M).
*
* Y (output) REAL array, dimension (LDY,NB)
* The n-by-nb matrix Y required to update the unreduced part
* of A.
*
* LDY (input) INTEGER
-* The leading dimension of the array Y. LDY >= N.
+* The leading dimension of the array Y. LDY >= max(1,N).
*
* Further Details
* ===============
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**T and G(i) = I - taup * u * u**T
*
* where tauq and taup are real scalars, and v and u are real vectors.
*
* A(i,i+1:n); tauq is stored in TAUQ(i) and taup in TAUP(i).
*
* The elements of the vectors v and u together form the m-by-nb matrix
-* V and the nb-by-n matrix U' which are needed, with X and Y, to apply
+* V and the nb-by-n matrix U**T which are needed, with X and Y, to apply
* the transformation to the unreduced part of the matrix, using a block
-* update of the form: A := A - V*Y' - X*U'.
+* update of the form: A := A - V*Y**T - X*U**T.
*
* The contents of A on exit are illustrated by the following examples
* with nb = 2:
* the case in which all eigenvalues and eigenvectors of a symmetric
* tridiagonal matrix 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**Tu, u is a vector of length N with ones in the
* CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.
*
* The eigenvectors of the original matrix are stored in Q, and the
DO 110 ITS = 1, N
*
* Solve U*x = scale*v for a right eigenvector
-* or U'*x = scale*v for a left eigenvector,
+* or U**T*x = scale*v for a left eigenvector,
* overwriting x on v.
*
CALL SLATRS( 'Upper', TRANS, 'Nonunit', NORMIN, N, B, LDB,
* SLAGS2 computes 2-by-2 orthogonal matrices U, V and Q, such
* that if ( UPPER ) then
*
-* U'*A*Q = U'*( A1 A2 )*Q = ( x 0 )
-* ( 0 A3 ) ( x x )
+* U**T *A*Q = U**T *( A1 A2 )*Q = ( x 0 )
+* ( 0 A3 ) ( x x )
* and
-* V'*B*Q = V'*( B1 B2 )*Q = ( x 0 )
-* ( 0 B3 ) ( x x )
+* V**T*B*Q = V**T *( B1 B2 )*Q = ( x 0 )
+* ( 0 B3 ) ( x x )
*
* or if ( .NOT.UPPER ) then
*
-* U'*A*Q = U'*( A1 0 )*Q = ( x x )
-* ( A2 A3 ) ( 0 x )
+* U**T *A*Q = U**T *( A1 0 )*Q = ( x x )
+* ( A2 A3 ) ( 0 x )
* and
-* V'*B*Q = V'*( B1 0 )*Q = ( x x )
-* ( B2 B3 ) ( 0 x )
+* V**T*B*Q = V**T*( B1 0 )*Q = ( x x )
+* ( B2 B3 ) ( 0 x )
*
* The rows of the transformed A and B are parallel, where
*
IF( ABS( CSL ).GE.ABS( SNL ) .OR. ABS( CSR ).GE.ABS( SNR ) )
$ THEN
*
-* Compute the (1,1) and (1,2) elements of U'*A and V'*B,
-* and (1,2) element of |U|'*|A| and |V|'*|B|.
+* Compute the (1,1) and (1,2) elements of U**T *A and V**T *B,
+* and (1,2) element of |U|**T *|A| and |V|**T *|B|.
*
UA11R = CSL*A1
UA12 = CSL*A2 + SNL*A3
AUA12 = ABS( CSL )*ABS( A2 ) + ABS( SNL )*ABS( A3 )
AVB12 = ABS( CSR )*ABS( B2 ) + ABS( SNR )*ABS( B3 )
*
-* zero (1,2) elements of U'*A and V'*B
+* zero (1,2) elements of U**T *A and V**T *B
*
IF( ( ABS( UA11R )+ABS( UA12 ) ).NE.ZERO ) THEN
IF( AUA12 / ( ABS( UA11R )+ABS( UA12 ) ).LE.AVB12 /
*
ELSE
*
-* Compute the (2,1) and (2,2) elements of U'*A and V'*B,
-* and (2,2) element of |U|'*|A| and |V|'*|B|.
+* Compute the (2,1) and (2,2) elements of U**T *A and V**T *B,
+* and (2,2) element of |U|**T *|A| and |V|**T *|B|.
*
UA21 = -SNL*A1
UA22 = -SNL*A2 + CSL*A3
AUA22 = ABS( SNL )*ABS( A2 ) + ABS( CSL )*ABS( A3 )
AVB22 = ABS( SNR )*ABS( B2 ) + ABS( CSR )*ABS( B3 )
*
-* zero (2,2) elements of U'*A and V'*B, and then swap.
+* zero (2,2) elements of U**T*A and V**T*B, and then swap.
*
IF( ( ABS( UA21 )+ABS( UA22 ) ).NE.ZERO ) THEN
IF( AUA22 / ( ABS( UA21 )+ABS( UA22 ) ).LE.AVB22 /
IF( ABS( CSR ).GE.ABS( SNR ) .OR. ABS( CSL ).GE.ABS( SNL ) )
$ THEN
*
-* Compute the (2,1) and (2,2) elements of U'*A and V'*B,
-* and (2,1) element of |U|'*|A| and |V|'*|B|.
+* Compute the (2,1) and (2,2) elements of U**T *A and V**T *B,
+* and (2,1) element of |U|**T *|A| and |V|**T *|B|.
*
UA21 = -SNR*A1 + CSR*A2
UA22R = CSR*A3
AUA21 = ABS( SNR )*ABS( A1 ) + ABS( CSR )*ABS( A2 )
AVB21 = ABS( SNL )*ABS( B1 ) + ABS( CSL )*ABS( B2 )
*
-* zero (2,1) elements of U'*A and V'*B.
+* zero (2,1) elements of U**T *A and V**T *B.
*
IF( ( ABS( UA21 )+ABS( UA22R ) ).NE.ZERO ) THEN
IF( AUA21 / ( ABS( UA21 )+ABS( UA22R ) ).LE.AVB21 /
*
ELSE
*
-* Compute the (1,1) and (1,2) elements of U'*A and V'*B,
-* and (1,1) element of |U|'*|A| and |V|'*|B|.
+* Compute the (1,1) and (1,2) elements of U**T *A and V**T *B,
+* and (1,1) element of |U|**T *|A| and |V|**T *|B|.
*
UA11 = CSR*A1 + SNR*A2
UA12 = SNR*A3
AUA11 = ABS( CSR )*ABS( A1 ) + ABS( SNR )*ABS( A2 )
AVB11 = ABS( CSL )*ABS( B1 ) + ABS( SNL )*ABS( B2 )
*
-* zero (1,1) elements of U'*A and V'*B, and then swap.
+* zero (1,1) elements of U**T*A and V**T*B, and then swap.
*
IF( ( ABS( UA11 )+ABS( UA12 ) ).NE.ZERO ) THEN
IF( AUA11 / ( ABS( UA11 )+ABS( UA12 ) ).LE.AVB11 /
60 CONTINUE
ELSE
*
-* Compute B := B + A'*X
+* Compute B := B + A**T*X
*
DO 80 J = 1, NRHS
IF( N.EQ.1 ) THEN
100 CONTINUE
ELSE
*
-* Compute B := B - A'*X
+* Compute B := B - A**T*X
*
DO 120 J = 1, NRHS
IF( N.EQ.1 ) THEN
*
* SLAGTS may be used to solve one of the systems of equations
*
-* (T - lambda*I)*x = y or (T - lambda*I)'*x = y,
+* (T - lambda*I)*x = y or (T - lambda*I)**T*x = y,
*
* where T is an n by n tridiagonal matrix, for x, following the
* factorization of (T - lambda*I) as
* and, if overflow would otherwise occur, the diagonal
* elements of U are to be perturbed. See argument TOL
* below.
-* = 2: The equations (T - lambda*I)'x = y are to be solved,
+* = 2: The equations (T - lambda*I)**Tx = y are to be solved,
* but diagonal elements of U are not to be perturbed.
-* = -2: The equations (T - lambda*I)'x = y are to be solved
+* = -2: The equations (T - lambda*I)**Tx = y are to be solved
* and, if overflow would otherwise occur, the diagonal
* elements of U are to be perturbed. See argument TOL
* below.
* SLAHR2 reduces the first NB columns of A real general n-BY-(n-k+1)
* matrix A so that elements below the k-th subdiagonal are zero. The
* reduction is performed by an orthogonal similarity transformation
-* Q' * A * Q. The routine returns the matrices V and T which determine
-* Q as a block reflector I - V*T*V', and also the matrix Y = A * V * T.
+* Q**T * A * Q. The routine returns the matrices V and T which determine
+* Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T.
*
* This is an auxiliary routine called by SGEHRD.
*
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit in
* The elements of the vectors v together form the (n-k+1)-by-nb matrix
* V which is needed, with T and Y, to apply the transformation to the
* unreduced part of the matrix, using an update of the form:
-* A := (I - V*T*V') * (A - Y*V').
+* A := (I - V*T*V**T) * (A - Y*V**T).
*
* The contents of A on exit are illustrated by the following example
* with n = 7, k = 3 and nb = 2:
*
* Update A(K+1:N,I)
*
-* Update I-th column of A - Y * V'
+* Update I-th column of A - Y * V**T
*
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' to this column (call it b) from the
+* Apply I - V * 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)
$ I-1, A( K+1, 1 ),
$ LDA, T( 1, NB ), 1 )
*
-* w := w + V2'*b2
+* w := w + V2**T * b2
*
CALL SGEMV( 'Transpose', N-K-I+1, I-1,
$ ONE, A( K+I, 1 ),
$ LDA, A( K+I, I ), 1, ONE, T( 1, NB ), 1 )
*
-* w := T'*w
+* w := T**T * w
*
CALL STRMV( 'Upper', 'Transpose', 'NON-UNIT',
$ I-1, T, LDT,
* SLAHRD reduces the first NB columns of a real general n-by-(n-k+1)
* matrix A so that elements below the k-th subdiagonal are zero. The
* reduction is performed by an orthogonal similarity transformation
-* Q' * A * Q. The routine returns the matrices V and T which determine
-* Q as a block reflector I - V*T*V', and also the matrix Y = A * V * T.
+* Q**T * A * Q. The routine returns the matrices V and T which determine
+* Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T.
*
* This is an OBSOLETE auxiliary routine.
* This routine will be 'deprecated' in a future release.
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit in
* The elements of the vectors v together form the (n-k+1)-by-nb matrix
* V which is needed, with T and Y, to apply the transformation to the
* unreduced part of the matrix, using an update of the form:
-* A := (I - V*T*V') * (A - Y*V').
+* A := (I - V*T*V**T) * (A - Y*V**T).
*
* The contents of A on exit are illustrated by the following example
* with n = 7, k = 3 and nb = 2:
*
* Update A(1:n,i)
*
-* Compute i-th column of A - Y * V'
+* Compute i-th column of A - Y * V**T
*
CALL SGEMV( 'No transpose', N, I-1, -ONE, Y, LDY,
$ A( K+I-1, 1 ), LDA, ONE, A( 1, I ), 1 )
*
-* Apply I - V * T' * V' 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', I-1, A( K+1, 1 ),
$ LDA, T( 1, NB ), 1 )
*
-* w := w + V2'*b2
+* w := w + V2**T *b2
*
CALL SGEMV( 'Transpose', N-K-I+1, I-1, ONE, A( K+I, 1 ),
$ LDA, A( K+I, I ), 1, ONE, T( 1, NB ), 1 )
*
-* w := T'*w
+* w := T**T *w
*
CALL STRMV( 'Upper', 'Transpose', 'Non-unit', I-1, T, LDT,
$ T( 1, NB ), 1 )
* diag(sest*sest, 0) + [alpha gamma] * [ alpha ]
* [ gamma ]
*
-* where alpha = x'*w.
+* where alpha = x**T*w.
*
* Arguments
* =========
*
IF( I.LT.N ) THEN
*
-* Apply H(i)' to A(offset+i:m,i+1:n) from the left.
+* Apply H(i)**T to A(offset+i:m,i+1:n) from the left.
*
AII = A( OFFPI, I )
A( OFFPI, I ) = ONE
END IF
*
* Apply previous Householder reflectors to column K:
-* A(RK:M,K) := A(RK:M,K) - A(RK:M,1:K-1)*F(K,1:K-1)'.
+* A(RK:M,K) := A(RK:M,K) - A(RK:M,1:K-1)*F(K,1:K-1)**T.
*
IF( K.GT.1 ) THEN
CALL SGEMV( 'No transpose', M-RK+1, K-1, -ONE, A( RK, 1 ),
*
* Compute Kth column of F:
*
-* Compute F(K+1:N,K) := tau(K)*A(RK:M,K+1:N)'*A(RK:M,K).
+* Compute F(K+1:N,K) := tau(K)*A(RK:M,K+1:N)**T*A(RK:M,K).
*
IF( K.LT.N ) THEN
CALL SGEMV( 'Transpose', M-RK+1, N-K, TAU( K ),
20 CONTINUE
*
* Incremental updating of F:
-* F(1:N,K) := F(1:N,K) - tau(K)*F(1:N,1:K-1)*A(RK:M,1:K-1)'
+* F(1:N,K) := F(1:N,K) - tau(K)*F(1:N,1:K-1)*A(RK:M,1:K-1)**T
* *A(RK:M,K).
*
IF( K.GT.1 ) THEN
END IF
*
* Update the current row of A:
-* A(RK,K+1:N) := A(RK,K+1:N) - A(RK,1:K)*F(K+1:N,1:K)'.
+* A(RK,K+1:N) := A(RK,K+1:N) - A(RK,1:K)*F(K+1:N,1:K)**T.
*
IF( K.LT.N ) THEN
CALL SGEMV( 'No transpose', N-K, K, -ONE, F( K+1, 1 ), LDF,
*
* Apply the block reflector to the rest of the matrix:
* A(OFFSET+KB+1:M,KB+1:N) := A(OFFSET+KB+1:M,KB+1:N) -
-* A(OFFSET+KB+1:M,1:KB)*F(KB+1:N,1:KB)'.
+* A(OFFSET+KB+1:M,1:KB)*F(KB+1:N,1:KB)**T.
*
IF( KB.LT.MIN( N, M-OFFSET ) ) THEN
CALL SGEMM( 'No transpose', 'Transpose', M-RK, N-KB, KB, -ONE,
* if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
*
* On exit, if INFO = 0, the triangular factor U or L from the
-* Cholesky factorization A = U'*U or A = L*L' of the band
+* Cholesky factorization A = U**T*U or A = L*L**T of the band
* matrix A, in the same storage format as A.
*
* LDAB (input) INTEGER
* LTRAN (input) LOGICAL
* On entry, LTRAN specifies the option of conjugate transpose:
* = .FALSE., op(T+i*B) = T+i*B,
-* = .TRUE., op(T+i*B) = (T+i*B)'.
+* = .TRUE., op(T+i*B) = (T+i*B)**T.
*
* LREAL (input) LOGICAL
* On entry, LREAL specifies the input matrix structure:
*
ELSE
*
-* Solve (T + iB)'*(p+iq) = c+id
+* Solve (T + iB)**T*(p+iq) = c+id
*
JNEXT = 1
DO 80 J = 1, N
*
* SLAR1V computes the (scaled) r-th column of the inverse of
* the sumbmatrix in rows B1 through BN of the tridiagonal matrix
-* L D L^T - sigma I. When sigma is close to an eigenvalue, the
+* L D L**T - sigma I. When sigma is close to an eigenvalue, the
* computed vector is an accurate eigenvector. Usually, r corresponds
* to the index where the eigenvector is largest in magnitude.
* The following steps accomplish this computation :
-* (a) Stationary qd transform, L D L^T - sigma I = L(+) D(+) L(+)^T,
-* (b) Progressive qd transform, L D L^T - sigma I = U(-) D(-) U(-)^T,
+* (a) Stationary qd transform, L D L**T - sigma I = L(+) D(+) L(+)**T,
+* (b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,
* (c) Computation of the diagonal elements of the inverse of
-* L D L^T - sigma I by combining the above transforms, and choosing
+* L D L**T - sigma I by combining the above transforms, and choosing
* r as the index where the diagonal of the inverse is (one of the)
* largest in magnitude.
* (d) Computation of the (scaled) r-th column of the inverse using the
* =========
*
* N (input) INTEGER
-* The order of the matrix L D L^T.
+* The order of the matrix L D L**T.
*
* B1 (input) INTEGER
-* First index of the submatrix of L D L^T.
+* First index of the submatrix of L D L**T.
*
* BN (input) INTEGER
-* Last index of the submatrix of L D L^T.
+* Last index of the submatrix of L D L**T.
*
-* LAMBDA (input) REAL
+* LAMBDA (input) REAL
* The shift. In order to compute an accurate eigenvector,
* LAMBDA should be a good approximation to an eigenvalue
-* of L D L^T.
+* of L D L**T.
*
-* L (input) REAL array, dimension (N-1)
+* L (input) REAL array, dimension (N-1)
* The (n-1) subdiagonal elements of the unit bidiagonal matrix
* L, in elements 1 to N-1.
*
-* D (input) REAL array, dimension (N)
+* D (input) REAL array, dimension (N)
* The n diagonal elements of the diagonal matrix D.
*
-* LD (input) REAL array, dimension (N-1)
+* LD (input) REAL array, dimension (N-1)
* The n-1 elements L(i)*D(i).
*
-* LLD (input) REAL array, dimension (N-1)
+* LLD (input) REAL array, dimension (N-1)
* The n-1 elements L(i)*L(i)*D(i).
*
-* PIVMIN (input) REAL
+* PIVMIN (input) REAL
* The minimum pivot in the Sturm sequence.
*
-* GAPTOL (input) REAL
+* GAPTOL (input) REAL
* Tolerance that indicates when eigenvector entries are negligible
* w.r.t. their contribution to the residual.
*
-* Z (input/output) REAL array, dimension (N)
+* Z (input/output) REAL array, dimension (N)
* On input, all entries of Z must be set to 0.
* On output, Z contains the (scaled) r-th column of the
* inverse. The scaling is such that Z(R) equals 1.
*
* NEGCNT (output) INTEGER
* If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin
-* in the matrix factorization L D L^T, and NEGCNT = -1 otherwise.
+* in the matrix factorization L D L**T, and NEGCNT = -1 otherwise.
*
-* ZTZ (output) REAL
+* ZTZ (output) REAL
* The square of the 2-norm of Z.
*
-* MINGMA (output) REAL
+* MINGMA (output) REAL
* The reciprocal of the largest (in magnitude) diagonal
-* element of the inverse of L D L^T - sigma I.
+* element of the inverse of L D L**T - sigma I.
*
* R (input/output) INTEGER
* The twist index for the twisted factorization used to
* compute Z.
* On input, 0 <= R <= N. If R is input as 0, R is set to
-* the index where (L D L^T - sigma I)^{-1} is largest
+* the index where (L D L**T - sigma I)^{-1} is largest
* in magnitude. If 1 <= R <= N, R is unchanged.
* On output, R contains the twist index used to compute Z.
* Ideally, R designates the position of the maximum entry in the
* The support of the vector in Z, i.e., the vector Z is
* nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 ).
*
-* NRMINV (output) REAL
+* NRMINV (output) REAL
* NRMINV = 1/SQRT( ZTZ )
*
-* RESID (output) REAL
+* RESID (output) REAL
* The residual of the FP vector.
* RESID = ABS( MINGMA )/SQRT( ZTZ )
*
-* RQCORR (output) REAL
+* RQCORR (output) REAL
* The Rayleigh Quotient correction to LAMBDA.
* RQCORR = MINGMA*TMP
*
-* WORK (workspace) REAL array, dimension (4*N)
+* WORK (workspace) REAL array, dimension (4*N)
*
* Further Details
* ===============
* SLARF applies a real elementary reflector H to a real m by n matrix
* C, from either the left or the right. H is represented in the form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**T
*
* where tau is a real scalar and v is a real vector.
*
*
IF( LASTV.GT.0 ) THEN
*
-* w(1:lastc,1) := C(1:lastv,1:lastc)' * v(1:lastv,1)
+* w(1:lastc,1) := C(1:lastv,1:lastc)**T * v(1:lastv,1)
*
CALL SGEMV( 'Transpose', LASTV, LASTC, ONE, C, LDC, V, INCV,
$ ZERO, WORK, 1 )
*
-* C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)'
+* C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)**T
*
CALL SGER( LASTV, LASTC, -TAU, V, INCV, WORK, 1, C, LDC )
END IF
CALL SGEMV( 'No transpose', LASTC, LASTV, ONE, C, LDC,
$ V, INCV, ZERO, WORK, 1 )
*
-* C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)'
+* C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)**T
*
CALL SGER( LASTC, LASTV, -TAU, WORK, 1, V, INCV, C, LDC )
END IF
* Purpose
* =======
*
-* SLARFB applies a real block reflector H or its transpose H' to a
+* SLARFB applies a real block reflector H or its transpose H**T to a
* real m by n matrix C, from either the left or the right.
*
* Arguments
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply H or H' from the Left
-* = 'R': apply H or H' from the Right
+* = 'L': apply H or H**T from the Left
+* = 'R': apply H or H**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply H (No transpose)
-* = 'T': apply H' (Transpose)
+* = 'T': apply H**T (Transpose)
*
* DIRECT (input) CHARACTER*1
* Indicates how H is formed from a product of elementary
*
* C (input/output) REAL array, dimension (LDC,N)
* On entry, the m by n matrix C.
-* On exit, C is overwritten by H*C or H'*C or C*H or C*H'.
+* On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T.
*
* LDC (input) INTEGER
-* The leading dimension of the array C. LDA >= max(1,M).
+* The leading dimension of the array C. LDC >= max(1,M).
*
* WORK (workspace) REAL array, dimension (LDWORK,K)
*
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**T * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILASLR( M, K, V, LDV ) )
LASTC = ILASLC( LASTV, N, C, LDC )
*
-* W := C' * V = (C1'*V1 + C2'*V2) (stored in WORK)
+* W := C**T * V = (C1**T * V1 + C2**T * V2) (stored in WORK)
*
-* W := C1'
+* W := C1**T
*
DO 10 J = 1, K
CALL SCOPY( LASTC, C( J, 1 ), LDC, WORK( 1, J ), 1 )
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2'*V2
+* W := W + C2**T *V2
*
CALL SGEMM( 'Transpose', 'No transpose',
$ LASTC, K, LASTV-K,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**T or W * T
*
CALL STRMM( 'Right', 'Upper', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V * W'
+* C := C - V * W**T
*
IF( LASTV.GT.K ) THEN
*
-* C2 := C2 - V2 * W'
+* C2 := C2 - V2 * W**T
*
CALL SGEMM( 'No transpose', 'Transpose',
$ LASTV-K, LASTC, K,
$ C( K+1, 1 ), LDC )
END IF
*
-* W := W * V1'
+* W := W * V1**T
*
CALL STRMM( 'Right', 'Lower', 'Transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
-* C1 := C1 - W'
+* C1 := C1 - W**T
*
DO 30 J = 1, K
DO 20 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**T where C = ( C1 C2 )
*
LASTV = MAX( K, ILASLR( N, K, V, LDV ) )
LASTC = ILASLR( M, LASTV, C, LDC )
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**T
*
CALL STRMM( 'Right', 'Upper', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - W * V'
+* C := C - W * V**T
*
IF( LASTV.GT.K ) THEN
*
-* C2 := C2 - W * V2'
+* C2 := C2 - W * V2**T
*
CALL SGEMM( 'No transpose', 'Transpose',
$ LASTC, LASTV-K, K,
$ C( 1, K+1 ), LDC )
END IF
*
-* W := W * V1'
+* W := W * V1**T
*
CALL STRMM( 'Right', 'Lower', 'Transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**T * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILASLR( M, K, V, LDV ) )
LASTC = ILASLC( LASTV, N, C, LDC )
*
-* W := C' * V = (C1'*V1 + C2'*V2) (stored in WORK)
+* W := C' * V = (C1**T * V1 + C2**T * V2) (stored in WORK)
*
-* W := C2'
+* W := C2**T
*
DO 70 J = 1, K
CALL SCOPY( LASTC, C( LASTV-K+J, 1 ), LDC,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1'*V1
+* W := W + C1**T*V1
*
CALL SGEMM( 'Transpose', 'No transpose',
$ LASTC, K, LASTV-K, ONE, C, LDC, V, LDV,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**T or W * T
*
CALL STRMM( 'Right', 'Lower', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V * W'
+* C := C - V * W**T
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - V1 * W'
+* C1 := C1 - V1 * W**T
*
CALL SGEMM( 'No transpose', 'Transpose',
$ LASTV-K, LASTC, K, -ONE, V, LDV, WORK, LDWORK,
$ ONE, C, LDC )
END IF
*
-* W := W * V2'
+* W := W * V2**T
*
CALL STRMM( 'Right', 'Upper', 'Transpose', 'Unit',
$ LASTC, K, ONE, V( LASTV-K+1, 1 ), LDV,
$ WORK, LDWORK )
*
-* C2 := C2 - W'
+* C2 := C2 - W**T
*
DO 90 J = 1, K
DO 80 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**T where C = ( C1 C2 )
*
LASTV = MAX( K, ILASLR( N, K, V, LDV ) )
LASTC = ILASLR( M, LASTV, C, LDC )
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**T
*
CALL STRMM( 'Right', 'Lower', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - W * V1'
+* C1 := C1 - W * V1**T
*
CALL SGEMM( 'No transpose', 'Transpose',
$ LASTC, LASTV-K, K, -ONE, WORK, LDWORK, V, LDV,
$ ONE, C, LDC )
END IF
*
-* W := W * V2'
+* W := W * V2**T
*
CALL STRMM( 'Right', 'Upper', 'Transpose', 'Unit',
$ LASTC, K, ONE, V( LASTV-K+1, 1 ), LDV,
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**T * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILASLC( K, M, V, LDV ) )
LASTC = ILASLC( LASTV, N, C, LDC )
*
-* W := C' * V' = (C1'*V1' + C2'*V2') (stored in WORK)
+* W := C**T * V**T = (C1**T * V1**T + C2**T * V2**T) (stored in WORK)
*
-* W := C1'
+* W := C1**T
*
DO 130 J = 1, K
CALL SCOPY( LASTC, C( J, 1 ), LDC, WORK( 1, J ), 1 )
130 CONTINUE
*
-* W := W * V1'
+* W := W * V1**T
*
CALL STRMM( 'Right', 'Upper', 'Transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2'*V2'
+* W := W + C2**T*V2**T
*
CALL SGEMM( 'Transpose', 'Transpose',
$ LASTC, K, LASTV-K,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**T or W * T
*
CALL STRMM( 'Right', 'Upper', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V' * W'
+* C := C - V**T * W**T
*
IF( LASTV.GT.K ) THEN
*
-* C2 := C2 - V2' * W'
+* C2 := C2 - V2**T * W**T
*
CALL SGEMM( 'Transpose', 'Transpose',
$ LASTV-K, LASTC, K,
CALL STRMM( 'Right', 'Upper', 'No transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
-* C1 := C1 - W'
+* C1 := C1 - W**T
*
DO 150 J = 1, K
DO 140 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**T where C = ( C1 C2 )
*
LASTV = MAX( K, ILASLC( K, N, V, LDV ) )
LASTC = ILASLR( M, LASTV, C, LDC )
*
-* W := C * V' = (C1*V1' + C2*V2') (stored in WORK)
+* W := C * V**T = (C1*V1**T + C2*V2**T) (stored in WORK)
*
* W := C1
*
CALL SCOPY( LASTC, C( 1, J ), 1, WORK( 1, J ), 1 )
160 CONTINUE
*
-* W := W * V1'
+* W := W * V1**T
*
CALL STRMM( 'Right', 'Upper', 'Transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2 * V2'
+* W := W + C2 * V2**T
*
CALL SGEMM( 'No transpose', 'Transpose',
$ LASTC, K, LASTV-K,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**T
*
CALL STRMM( 'Right', 'Upper', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**T * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILASLC( K, M, V, LDV ) )
LASTC = ILASLC( LASTV, N, C, LDC )
*
-* W := C' * V' = (C1'*V1' + C2'*V2') (stored in WORK)
+* W := C**T * V**T = (C1**T * V1**T + C2**T * V2**T) (stored in WORK)
*
-* W := C2'
+* W := C2**T
*
DO 190 J = 1, K
CALL SCOPY( LASTC, C( LASTV-K+J, 1 ), LDC,
$ WORK( 1, J ), 1 )
190 CONTINUE
*
-* W := W * V2'
+* W := W * V2**T
*
CALL STRMM( 'Right', 'Lower', 'Transpose', 'Unit',
$ LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1'*V1'
+* W := W + C1**T * V1**T
*
CALL SGEMM( 'Transpose', 'Transpose',
$ LASTC, K, LASTV-K, ONE, C, LDC, V, LDV,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**T or W * T
*
CALL STRMM( 'Right', 'Lower', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V' * W'
+* C := C - V**T * W**T
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - V1' * W'
+* C1 := C1 - V1**T * W**T
*
CALL SGEMM( 'Transpose', 'Transpose',
$ LASTV-K, LASTC, K, -ONE, V, LDV, WORK, LDWORK,
$ LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
*
-* C2 := C2 - W'
+* C2 := C2 - W**T
*
DO 210 J = 1, K
DO 200 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**T where C = ( C1 C2 )
*
LASTV = MAX( K, ILASLC( K, N, V, LDV ) )
LASTC = ILASLR( M, LASTV, C, LDC )
*
-* W := C * V' = (C1*V1' + C2*V2') (stored in WORK)
+* W := C * V**T = (C1*V1**T + C2*V2**T) (stored in WORK)
*
* W := C2
*
$ WORK( 1, J ), 1 )
220 CONTINUE
*
-* W := W * V2'
+* W := W * V2**T
*
CALL STRMM( 'Right', 'Lower', 'Transpose', 'Unit',
$ LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1 * V1'
+* W := W + C1 * V1**T
*
CALL SGEMM( 'No transpose', 'Transpose',
$ LASTC, K, LASTV-K, ONE, C, LDC, V, LDV,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**T
*
CALL STRMM( 'Right', 'Lower', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
* SLARFG generates a real elementary reflector H of order n, such
* that
*
-* H * ( alpha ) = ( beta ), H' * H = I.
+* H * ( alpha ) = ( beta ), H**T * H = I.
* ( x ) ( 0 )
*
* where alpha and beta are scalars, and x is an (n-1)-element real
* vector. H is represented in the form
*
-* H = I - tau * ( 1 ) * ( 1 v' ) ,
+* H = I - tau * ( 1 ) * ( 1 v**T ) ,
* ( v )
*
* where tau is a real scalar and v is a real (n-1)-element
* SLARFGP generates a real elementary reflector H of order n, such
* that
*
-* H * ( alpha ) = ( beta ), H' * H = I.
+* H * ( alpha ) = ( beta ), H**T * H = I.
* ( x ) ( 0 )
*
* where alpha and beta are scalars, beta is non-negative, and x is
* an (n-1)-element real vector. H is represented in the form
*
-* H = I - tau * ( 1 ) * ( 1 v' ) ,
+* H = I - tau * ( 1 ) * ( 1 v**T ) ,
* ( v )
*
* where tau is a real scalar and v is a real (n-1)-element
* 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
*
* Arguments
* =========
END DO
J = MIN( LASTV, PREVLASTV )
*
-* T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)' * V(i:j,i)
+* T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)**T * V(i:j,i)
*
CALL SGEMV( 'Transpose', J-I+1, I-1, -TAU( I ),
$ V( I, 1 ), LDV, V( I, I ), 1, ZERO,
END DO
J = MIN( LASTV, PREVLASTV )
*
-* T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)'
+* T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)**T
*
CALL SGEMV( 'No transpose', I-1, J-I+1, -TAU( I ),
$ V( 1, I ), LDV, V( I, I ), LDV, ZERO,
J = MAX( LASTV, PREVLASTV )
*
* T(i+1:k,i) :=
-* - tau(i) * V(j:n-k+i,i+1:k)' * V(j:n-k+i,i)
+* - tau(i) * V(j:n-k+i,i+1:k)**T * V(j:n-k+i,i)
*
CALL SGEMV( 'Transpose', N-K+I-J+1, K-I, -TAU( I ),
$ V( J, I+1 ), LDV, V( J, I ), 1, ZERO,
J = MAX( LASTV, PREVLASTV )
*
* T(i+1:k,i) :=
-* - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)'
+* - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)**T
*
CALL SGEMV( 'No transpose', K-I, N-K+I-J+1,
$ -TAU( I ), V( I+1, J ), LDV, V( I, J ), LDV,
* matrix C, from either the left or the right. H is represented in the
* form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**T
*
* where tau is a real scalar and v is a real vector.
*
* =======
*
* SLARRV computes the eigenvectors of the tridiagonal matrix
-* T = L D L^T given L, D and APPROXIMATIONS to the eigenvalues of L D L^T.
+* T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T.
* The input eigenvalues should have been computed by SLARRE.
*
* Arguments
* matrix C, from either the left or the right. H is represented in the
* form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**T
*
* where tau is a real scalar and v is a real vector.
*
*
CALL SCOPY( N, C, LDC, WORK, 1 )
*
-* w( 1:n ) = w( 1:n ) + C( m-l+1:m, 1:n )' * v( 1:l )
+* w( 1:n ) = w( 1:n ) + C( m-l+1:m, 1:n )**T * v( 1:l )
*
CALL SGEMV( 'Transpose', L, N, ONE, C( M-L+1, 1 ), LDC, V,
$ INCV, ONE, WORK, 1 )
CALL SAXPY( N, -TAU, WORK, 1, C, LDC )
*
* C( m-l+1:m, 1:n ) = C( m-l+1:m, 1:n ) - ...
-* tau * v( 1:l ) * w( 1:n )'
+* tau * v( 1:l ) * w( 1:n )**T
*
CALL SGER( L, N, -TAU, V, INCV, WORK, 1, C( M-L+1, 1 ),
$ LDC )
CALL SAXPY( M, -TAU, WORK, 1, C, 1 )
*
* C( 1:m, n-l+1:n ) = C( 1:m, n-l+1:n ) - ...
-* tau * w( 1:m ) * v( 1:l )'
+* tau * w( 1:m ) * v( 1:l )**T
*
CALL SGER( M, L, -TAU, WORK, 1, V, INCV, C( 1, N-L+1 ),
$ LDC )
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply H or H' from the Left
-* = 'R': apply H or H' from the Right
+* = 'L': apply H or H**T from the Left
+* = 'R': apply H or H**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply H (No transpose)
-* = 'C': apply H' (Transpose)
+* = 'C': apply H**T (Transpose)
*
* DIRECT (input) CHARACTER*1
* Indicates how H is formed from a product of elementary
*
* C (input/output) REAL array, dimension (LDC,N)
* On entry, the M-by-N matrix C.
-* On exit, C is overwritten by H*C or H'*C or C*H or C*H'.
+* On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C
+* Form H * C or H**T * C
*
-* W( 1:n, 1:k ) = C( 1:k, 1:n )'
+* W( 1:n, 1:k ) = C( 1:k, 1:n )**T
*
DO 10 J = 1, K
CALL SCOPY( N, C( J, 1 ), LDC, WORK( 1, J ), 1 )
10 CONTINUE
*
* W( 1:n, 1:k ) = W( 1:n, 1:k ) + ...
-* C( m-l+1:m, 1:n )' * V( 1:k, 1:l )'
+* C( m-l+1:m, 1:n )**T * V( 1:k, 1:l )**T
*
IF( L.GT.0 )
$ CALL SGEMM( 'Transpose', 'Transpose', N, K, L, ONE,
CALL STRMM( 'Right', 'Lower', TRANST, 'Non-unit', N, K, ONE, T,
$ LDT, WORK, LDWORK )
*
-* C( 1:k, 1:n ) = C( 1:k, 1:n ) - W( 1:n, 1:k )'
+* C( 1:k, 1:n ) = C( 1:k, 1:n ) - W( 1:n, 1:k )**T
*
DO 30 J = 1, N
DO 20 I = 1, K
30 CONTINUE
*
* C( m-l+1:m, 1:n ) = C( m-l+1:m, 1:n ) - ...
-* V( 1:k, 1:l )' * W( 1:n, 1:k )'
+* V( 1:k, 1:l )**T * W( 1:n, 1:k )**T
*
IF( L.GT.0 )
$ CALL SGEMM( 'Transpose', 'Transpose', L, N, K, -ONE, V, LDV,
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H'
+* Form C * H or C * H**T
*
* W( 1:m, 1:k ) = C( 1:m, 1:k )
*
40 CONTINUE
*
* W( 1:m, 1:k ) = W( 1:m, 1:k ) + ...
-* C( 1:m, n-l+1:n ) * V( 1:k, 1:l )'
+* C( 1:m, n-l+1:n ) * V( 1:k, 1:l )**T
*
IF( L.GT.0 )
$ CALL SGEMM( 'No transpose', 'Transpose', M, K, L, ONE,
$ C( 1, N-L+1 ), LDC, V, LDV, ONE, WORK, LDWORK )
*
-* W( 1:m, 1:k ) = W( 1:m, 1:k ) * T or W( 1:m, 1:k ) * T'
+* W( 1:m, 1:k ) = W( 1:m, 1:k ) * T or W( 1:m, 1:k ) * T**T
*
CALL STRMM( 'Right', 'Lower', TRANS, 'Non-unit', M, K, ONE, T,
$ LDT, WORK, LDWORK )
*
IF( I.LT.K ) THEN
*
-* T(i+1:k,i) = - tau(i) * V(i+1:k,1:n) * V(i,1:n)'
+* T(i+1:k,i) = - tau(i) * V(i+1:k,1:n) * V(i,1:n)**T
*
CALL SGEMV( 'No transpose', K-I, N, -TAU( I ),
$ V( I+1, 1 ), LDV, V( I, 1 ), LDV, ZERO,
*
* VT (input/output) REAL array, dimension (LDVT,M)
* where M = N + SQRE.
-* On entry VT(1:NL+1, 1:NL+1)' contains the right singular
-* vectors of the upper block; VT(NL+2:M, NL+2:M)' contains
+* 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
* bidiagonal matrix.
* using the Bunch-Kaufman diagonal pivoting method. The partial
* factorization has the form:
*
-* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
-* ( 0 U22 ) ( 0 D ) ( U12' U22' )
+* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
+* ( 0 U22 ) ( 0 D ) ( U12**T U22**T )
*
-* A = ( L11 0 ) ( D 0 ) ( L11' L21' ) if UPLO = 'L'
-* ( L21 I ) ( 0 A22 ) ( 0 I )
+* A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L'
+* ( L21 I ) ( 0 A22 ) ( 0 I )
*
* where the order of D is at most NB. The actual order is returned in
* the argument KB, and is either NB or NB-1, or N if N <= NB.
*
* Update the upper triangle of A11 (= A(1:k,1:k)) as
*
-* A11 := A11 - U12*D*U12' = A11 - U12*W'
+* A11 := A11 - U12*D*U12**T = A11 - U12*W**T
*
* computing blocks of NB columns at a time
*
*
* Update the lower triangle of A22 (= A(k:n,k:n)) as
*
-* A22 := A22 - L21*D*L21' = A22 - L21*W'
+* A22 := A22 - L21*D*L21**T = A22 - L21*W**T
*
* computing blocks of NB columns at a time
*
*
* SLATRD reduces NB rows and columns of a real symmetric matrix A to
* symmetric tridiagonal form by an orthogonal similarity
-* transformation Q' * A * Q, and returns the matrices V and W which are
+* transformation Q**T * A * Q, and returns the matrices V and W which are
* needed to apply the transformation to the unreduced part of A.
*
* If UPLO = 'U', SLATRD reduces the last NB rows and columns of a
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(i:n) = 0 and v(i-1) = 1; v(1:i-1) is stored on exit in A(1:i-1,i),
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+1:n) is stored on exit in A(i+1:n,i),
* The elements of the vectors v together form the n-by-nb matrix V
* which is needed, with W, to apply the transformation to the unreduced
* part of the matrix, using a symmetric rank-2k update of the form:
-* A := A - V*W' - W*V'.
+* A := A - V*W**T - W*V**T.
*
* The contents of A on exit are illustrated by the following examples
* with n = 5 and nb = 2:
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
+* T( k ) = I - tau*u( k )*u( k )**T, u( k ) = ( 1 ),
* ( 0 )
* ( z( k ) )
*
*
* SLATZM applies a Householder matrix generated by STZRQF to a matrix.
*
-* Let P = I - tau*u*u', u = ( 1 ),
-* ( v )
+* Let P = I - tau*u*u**T, u = ( 1 ),
+* ( v )
* where v is an (m-1) vector if SIDE = 'L', or a (n-1) vector if
* SIDE = 'R'.
*
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* w := C1 + v' * C2
+* w := (C1 + v**T * C2)**T
*
CALL SCOPY( N, C1, LDC, WORK, 1 )
CALL SGEMV( 'Transpose', M-1, N, ONE, C2, LDC, V, INCV, ONE,
$ WORK, 1 )
*
-* [ C1 ] := [ C1 ] - tau* [ 1 ] * w'
+* [ C1 ] := [ C1 ] - tau* [ 1 ] * w**T
* [ C2 ] [ C2 ] [ v ]
*
CALL SAXPY( N, -TAU, WORK, 1, C1, LDC )
CALL SGEMV( 'No transpose', M, N-1, ONE, C2, LDC, V, INCV, ONE,
$ WORK, 1 )
*
-* [ C1, C2 ] := [ C1, C2 ] - tau* w * [ 1 , v']
+* [ C1, C2 ] := [ C1, C2 ] - tau* w * [ 1 , v**T]
*
CALL SAXPY( M, -TAU, WORK, 1, C1, 1 )
CALL SGER( M, N-1, -TAU, WORK, 1, V, INCV, C2, LDC )
* Purpose
* =======
*
-* SLAUU2 computes the product U * U' or L' * L, where the triangular
+* SLAUU2 computes the product U * U**T or L**T * L, where the triangular
* factor U or L is stored in the upper or lower triangular part of
* the array A.
*
* A (input/output) REAL array, dimension (LDA,N)
* On entry, the triangular factor U or L.
* On exit, if UPLO = 'U', the upper triangle of A is
-* overwritten with the upper triangle of the product U * U';
+* overwritten with the upper triangle of the product U * U**T;
* if UPLO = 'L', the lower triangle of A is overwritten with
-* the lower triangle of the product L' * L.
+* the lower triangle of the product L**T * L.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the product U * U'.
+* Compute the product U * U**T.
*
DO 10 I = 1, N
AII = A( I, I )
*
ELSE
*
-* Compute the product L' * L.
+* Compute the product L**T * L.
*
DO 20 I = 1, N
AII = A( I, I )
* Purpose
* =======
*
-* SLAUUM computes the product U * U' or L' * L, where the triangular
+* SLAUUM computes the product U * U**T or L**T * L, where the triangular
* factor U or L is stored in the upper or lower triangular part of
* the array A.
*
* A (input/output) REAL array, dimension (LDA,N)
* On entry, the triangular factor U or L.
* On exit, if UPLO = 'U', the upper triangle of A is
-* overwritten with the upper triangle of the product U * U';
+* overwritten with the upper triangle of the product U * U**T;
* if UPLO = 'L', the lower triangle of A is overwritten with
-* the lower triangle of the product L' * L.
+* the lower triangle of the product L**T * L.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the product U * U'.
+* Compute the product U * U**T.
*
DO 10 I = 1, N, NB
IB = MIN( NB, N-I+1 )
10 CONTINUE
ELSE
*
-* Compute the product L' * L.
+* Compute the product L**T * L.
*
DO 20 I = 1, N, NB
IB = MIN( NB, N-I+1 )
CALL SLARFT( 'Forward', 'Rowwise', N-I+1, IB, A( I, I ),
$ LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i+ib:m,i:n) from the right
+* Apply H**T to A(i+ib:m,i:n) from the right
*
CALL SLARFB( 'Right', 'Transpose', 'Forward', 'Rowwise',
$ M-I-IB+1, N-I+1, IB, A( I, I ), LDA, WORK,
$ LDWORK )
END IF
*
-* Apply H' to columns i:n of current block
+* Apply H**T to columns i:n of current block
*
CALL SORGL2( IB, N-I+1, IB, A( I, I ), LDA, TAU( I ), WORK,
$ IINFO )
CALL SLARFT( 'Backward', 'Rowwise', N-K+I+IB-1, IB,
$ A( II, 1 ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(1:m-k+i-1,1:n-k+i+ib-1) from the right
+* Apply H**T to A(1:m-k+i-1,1:n-k+i+ib-1) from the right
*
CALL SLARFB( 'Right', 'Transpose', 'Backward', 'Rowwise',
$ II-1, N-K+I+IB-1, IB, A( II, 1 ), LDA, WORK,
$ LDWORK, A, LDA, WORK( IB+1 ), LDWORK )
END IF
*
-* Apply H' to columns 1:n-k+i+ib-1 of current block
+* Apply H**T to columns 1:n-k+i+ib-1 of current block
*
CALL SORGR2( IB, N-K+I+IB-1, IB, A( II, 1 ), LDA, TAU( I ),
$ WORK, IINFO )
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'T', or
+* Q**T * C if SIDE = 'L' and TRANS = 'T', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'T',
+* C * Q**T if SIDE = 'R' and TRANS = 'T',
*
* where Q is a real orthogonal matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**T from the Left
+* = 'R': apply Q or Q**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'T': apply Q' (Transpose)
+* = 'T': apply Q**T (Transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) REAL array, dimension (LDC,N)
* On entry, the m by n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'T', or
+* Q**T* C if SIDE = 'L' and TRANS = 'T', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'T',
+* C * Q**T if SIDE = 'R' and TRANS = 'T',
*
* where Q is a real orthogonal matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**T from the Left
+* = 'R': apply Q or Q**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'T': apply Q' (Transpose)
+* = 'T': apply Q**T (Transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) REAL array, dimension (LDC,N)
* On entry, the m by n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'T', or
+* Q**T* C if SIDE = 'L' and TRANS = 'T', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'T',
+* C * Q**T if SIDE = 'R' and TRANS = 'T',
*
* where Q is a real orthogonal matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**T from the Left
+* = 'R': apply Q or Q**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'T': apply Q' (Transpose)
+* = 'T': apply Q**T (Transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) REAL array, dimension (LDC,N)
* On entry, the m by n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
$ LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**T is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**T is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**T
*
CALL SLARFB( SIDE, TRANST, 'Forward', 'Rowwise', MI, NI, IB,
$ A( I, I ), LDA, T, LDT, C( IC, JC ), LDC, WORK,
$ A( 1, I ), LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(1:m-k+i+ib-1,1:n)
+* H or H**T is applied to C(1:m-k+i+ib-1,1:n)
*
MI = M - K + I + IB - 1
ELSE
*
-* H or H' is applied to C(1:m,1:n-k+i+ib-1)
+* H or H**T is applied to C(1:m,1:n-k+i+ib-1)
*
NI = N - K + I + IB - 1
END IF
*
-* Apply H or H'
+* Apply H or H**T
*
CALL SLARFB( SIDE, TRANS, 'Backward', 'Columnwise', MI, NI,
$ IB, A( 1, I ), LDA, T, LDT, C, LDC, WORK,
$ LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**T is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**T is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**T
*
CALL SLARFB( SIDE, TRANS, 'Forward', 'Columnwise', MI, NI,
$ IB, A( I, I ), LDA, T, LDT, C( IC, JC ), LDC,
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'T', or
+* Q**T* C if SIDE = 'L' and TRANS = 'T', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'T',
+* C * Q**T if SIDE = 'R' and TRANS = 'T',
*
* where Q is a real orthogonal matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**T from the Left
+* = 'R': apply Q or Q**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
*
* C (input/output) REAL array, dimension (LDC,N)
* On entry, the m by n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'T', or
+* Q**T* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'T',
+* C * Q**T if SIDE = 'R' and TRANS = 'C',
*
* where Q is a real orthogonal matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**T from the Left
+* = 'R': apply Q or Q**T from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'T': apply Q' (Transpose)
+* = 'T': apply Q**T (Transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) REAL array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(i:m,1:n)
+* H(i) or H(i)**T is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,i:n)
+* H(i) or H(i)**T is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**T
*
CALL SLARZ( SIDE, MI, NI, L, A( I, JA ), LDA, TAU( I ),
$ C( IC, JC ), LDC, WORK )
$ A( I, 1 ), LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(1:m-k+i+ib-1,1:n)
+* H or H**T is applied to C(1:m-k+i+ib-1,1:n)
*
MI = M - K + I + IB - 1
ELSE
*
-* H or H' is applied to C(1:m,1:n-k+i+ib-1)
+* H or H**T is applied to C(1:m,1:n-k+i+ib-1)
*
NI = N - K + I + IB - 1
END IF
*
-* Apply H or H'
+* Apply H or H**T
*
CALL SLARFB( SIDE, TRANST, 'Backward', 'Rowwise', MI, NI,
$ IB, A( I, 1 ), LDA, T, LDT, C, LDC, WORK,
*
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**T is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**T is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**T
*
CALL SLARZB( SIDE, TRANST, 'Backward', 'Rowwise', MI, NI,
$ IB, L, A( I, JA ), LDA, T, LDT, C( IC, JC ),
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**T).
*
CALL SLATBS( 'Upper', 'Transpose', 'Non-unit', NORMIN, N,
$ KD, AB, LDAB, WORK, SCALEL, WORK( 2*N+1 ),
$ INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**T).
*
CALL SLATBS( 'Lower', 'Transpose', 'Non-unit', NORMIN, N,
$ KD, AB, LDAB, WORK, SCALEU, WORK( 2*N+1 ),
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T*U or A = L*L**T.
*
CALL SPBTRF( UPLO, N, KD, AB, LDAB, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T *U or A = L*L**T.
*
IF( UPPER ) THEN
DO 40 J = 1, N
* positive definite band matrix A.
*
* The factorization has the form
-* A = U' * U , if UPLO = 'U', or
-* A = L * L', if UPLO = 'L',
-* where U is an upper triangular matrix, U' is the transpose of U, and
+* A = U**T * U , if UPLO = 'U', or
+* A = L * L**T, if UPLO = 'L',
+* where U is an upper triangular matrix, U**T is the transpose of U, and
* L is lower triangular.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
*
* On exit, if INFO = 0, the triangular factor U or L from the
-* Cholesky factorization A = U'*U or A = L*L' of the band
+* Cholesky factorization A = U**T*U or A = L*L**T of the band
* matrix A, in the same storage format as A.
*
* LDAB (input) INTEGER
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**T*U.
*
DO 10 J = 1, N
*
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**T.
*
DO 20 J = 1, N
*
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**T *U.
*
DO 10 J = 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, KD, AB,
$ LDAB, B( 1, J ), 1 )
10 CONTINUE
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L*L**T.
*
DO 20 J = 1, NRHS
*
CALL STBSV( 'Lower', 'No transpose', 'Non-unit', N, KD, AB,
$ LDAB, B( 1, J ), 1 )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**T *X = B, overwriting B with X.
*
CALL STBSV( 'Lower', 'Transpose', 'Non-unit', N, KD, AB,
$ LDAB, B( 1, J ), 1 )
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**T).
*
CALL SLATRS( 'Upper', 'Transpose', 'Non-unit', NORMIN, N, A,
$ LDA, WORK, SCALEL, WORK( 2*N+1 ), INFO )
$ A, LDA, WORK, SCALEL, WORK( 2*N+1 ), INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**T).
*
CALL SLATRS( 'Lower', 'Transpose', 'Non-unit', NORMIN, N, A,
$ LDA, WORK, SCALEU, WORK( 2*N+1 ), INFO )
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T*U or A = L*L**T.
*
CALL SPOTRF( UPLO, N, A, LDA, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T *U or A = L*L**T.
*
CALL SLACPY( UPLO, N, N, A, LDA, AF, LDAF )
CALL SPOTRF( UPLO, N, AF, LDAF, INFO )
* positive definite matrix A.
*
* The factorization has the form
-* A = U' * U , if UPLO = 'U', or
-* A = L * L', if UPLO = 'L',
+* A = U**T * U , if UPLO = 'U', or
+* A = L * L**T, if UPLO = 'L',
* where U is an upper triangular matrix and L is lower triangular.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* triangular part of A is not referenced.
*
* On exit, if INFO = 0, the factor U or L from the Cholesky
-* factorization A = U'*U or A = L*L'.
+* factorization A = U**T *U or A = L*L**T.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**T *U.
*
DO 10 J = 1, N
*
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**T.
*
DO 20 J = 1, N
*
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**T*U.
*
DO 10 J = 1, N, NB
*
*
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**T.
*
DO 20 J = 1, N, NB
*
IF( INFO.GT.0 )
$ RETURN
*
-* Form inv(U)*inv(U)' or inv(L)'*inv(L).
+* Form inv(U) * inv(U)**T or inv(L)**T * inv(L).
*
CALL SLAUUM( UPLO, N, A, LDA, INFO )
*
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**T *U.
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**T *X = B, overwriting B with X.
*
CALL STRSM( 'Left', 'Upper', 'Transpose', 'Non-unit', N, NRHS,
$ ONE, A, LDA, B, LDB )
$ NRHS, ONE, A, LDA, B, LDB )
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L*L**T.
*
* Solve L*X = B, overwriting B with X.
*
CALL STRSM( 'Left', 'Lower', 'No transpose', 'Non-unit', N,
$ NRHS, ONE, A, LDA, B, LDB )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**T *X = B, overwriting B with X.
*
CALL STRSM( 'Left', 'Lower', 'Transpose', 'Non-unit', N, NRHS,
$ ONE, A, LDA, B, LDB )
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**T).
*
CALL SLATPS( 'Upper', 'Transpose', 'Non-unit', NORMIN, N,
$ AP, WORK, SCALEL, WORK( 2*N+1 ), INFO )
$ AP, WORK, SCALEL, WORK( 2*N+1 ), INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**T).
*
CALL SLATPS( 'Lower', 'Transpose', 'Non-unit', NORMIN, N,
$ AP, WORK, SCALEU, WORK( 2*N+1 ), INFO )
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T*U or A = L*L**T.
*
CALL SPPTRF( UPLO, N, AP, INFO )
IF( INFO.EQ.0 ) THEN
* (N*(N+1)/2)
* If FACT = 'F', then AFP is an input argument and on entry
* contains the triangular factor U or L from the Cholesky
-* factorization A = U'*U or A = L*L', in the same storage
+* factorization A = U**T*U or A = L*L**T, in the same storage
* format as A. If EQUED .ne. 'N', then AFP is the factored
* form of the equilibrated matrix A.
*
* If FACT = 'N', then AFP is an output argument and on exit
* returns the triangular factor U or L from the Cholesky
-* factorization A = U'*U or A = L*L' of the original matrix A.
+* factorization A = U**T * U or A = L * L**T of the original
+* matrix A.
*
* If FACT = 'E', then AFP is an output argument and on exit
* returns the triangular factor U or L from the Cholesky
-* factorization A = U'*U or A = L*L' of the equilibrated
+* factorization A = U**T * U or A = L * L**T of the equilibrated
* matrix A (see the description of AP for the form of the
* equilibrated matrix).
*
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**T * U or A = L * L**T.
*
CALL SCOPY( N*( N+1 ) / 2, AP, 1, AFP, 1 )
CALL SPPTRF( UPLO, N, AFP, INFO )
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**T*U.
*
JJ = 0
DO 10 J = 1, N
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**T.
*
JJ = 1
DO 20 J = 1, N
*
IF( UPPER ) THEN
*
-* Compute the product inv(U) * inv(U)'.
+* Compute the product inv(U) * inv(U)**T.
*
JJ = 0
DO 10 J = 1, N
*
ELSE
*
-* Compute the product inv(L)' * inv(L).
+* Compute the product inv(L)**T * inv(L).
*
JJ = 1
DO 20 J = 1, N
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**T * U.
*
DO 10 I = 1, NRHS
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**T *X = B, overwriting B with X.
*
CALL STPSV( 'Upper', 'Transpose', 'Non-unit', N, AP,
$ B( 1, I ), 1 )
10 CONTINUE
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L * L**T.
*
DO 20 I = 1, NRHS
*
CALL STPSV( 'Lower', 'No transpose', 'Non-unit', N, AP,
$ B( 1, I ), 1 )
*
-* Solve L'*X = Y, overwriting B with X.
+* Solve L**T *X = Y, overwriting B with X.
*
CALL STPSV( 'Lower', 'Transpose', 'Non-unit', N, AP,
$ B( 1, I ), 1 )
* 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)'.
+* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**T.
*
* Solve M(L) * x = e.
*
WORK( I ) = ONE + WORK( I-1 )*ABS( E( I-1 ) )
20 CONTINUE
*
-* Solve D * M(L)' * x = b.
+* Solve D * M(L)**T * x = b.
*
WORK( N ) = WORK( N ) / D( N )
DO 30 I = N - 1, 1, -1
* 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)'.
+* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**T.
*
* Solve M(L) * x = e.
*
WORK( I ) = ONE + WORK( I-1 )*ABS( EF( I-1 ) )
60 CONTINUE
*
-* Solve D * M(L)' * x = b.
+* Solve D * M(L)**T * x = b.
*
WORK( N ) = WORK( N ) / DF( N )
DO 70 I = N - 1, 1, -1
RETURN
END IF
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**T (or U**T*D*U) factorization of A.
*
CALL SPTTRF( N, D, E, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**T (or U**T*D*U) factorization of A.
*
CALL SCOPY( N, D, 1, DF, 1 )
IF( N.GT.1 )
* Purpose
* =======
*
-* SPTTRF computes the L*D*L' factorization of a real symmetric
+* SPTTRF computes the L*D*L**T factorization of a real symmetric
* positive definite tridiagonal matrix A. The factorization may also
-* be regarded as having the form A = U'*D*U.
+* be regarded as having the form A = U**T*D*U.
*
* Arguments
* =========
* D (input/output) REAL array, dimension (N)
* On entry, the n diagonal elements of the tridiagonal matrix
* A. On exit, the n diagonal elements of the diagonal matrix
-* D from the L*D*L' factorization of A.
+* D from the L*D*L**T factorization of A.
*
* E (input/output) REAL array, dimension (N-1)
* On entry, the (n-1) subdiagonal elements of the tridiagonal
* matrix A. On exit, the (n-1) subdiagonal elements of the
-* unit bidiagonal factor L from the L*D*L' factorization of A.
+* unit bidiagonal factor L from the L*D*L**T factorization of A.
* E can also be regarded as the superdiagonal of the unit
-* bidiagonal factor U from the U'*D*U factorization of A.
+* bidiagonal factor U from the U**T*D*U factorization of A.
*
* INFO (output) INTEGER
* = 0: successful exit
IF( N.EQ.0 )
$ RETURN
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**T (or U**T*D*U) factorization of A.
*
I4 = MOD( N-1, 4 )
DO 10 I = 1, I4
*
* SPTTRS solves a tridiagonal system of the form
* A * X = B
-* using the L*D*L' factorization of A computed by SPTTRF. D is a
+* using the L*D*L**T factorization of A computed by SPTTRF. D is a
* diagonal matrix specified in the vector D, L is a unit bidiagonal
* matrix whose subdiagonal is specified in the vector E, and X and B
* are N by NRHS matrices.
*
* D (input) REAL array, dimension (N)
* The n diagonal elements of the diagonal matrix D from the
-* L*D*L' factorization of A.
+* L*D*L**T factorization of A.
*
* E (input) REAL array, dimension (N-1)
* The (n-1) subdiagonal elements of the unit bidiagonal factor
-* L from the L*D*L' factorization of A. E can also be regarded
+* L from the L*D*L**T factorization of A. E can also be regarded
* as the superdiagonal of the unit bidiagonal factor U from the
-* factorization A = U'*D*U.
+* factorization A = U**T*D*U.
*
* B (input/output) REAL array, dimension (LDB,NRHS)
* On entry, the right hand side vectors B for the system of
*
* SPTTS2 solves a tridiagonal system of the form
* A * X = B
-* using the L*D*L' factorization of A computed by SPTTRF. D is a
+* using the L*D*L**T factorization of A computed by SPTTRF. D is a
* diagonal matrix specified in the vector D, L is a unit bidiagonal
* matrix whose subdiagonal is specified in the vector E, and X and B
* are N by NRHS matrices.
*
* D (input) REAL array, dimension (N)
* The n diagonal elements of the diagonal matrix D from the
-* L*D*L' factorization of A.
+* L*D*L**T factorization of A.
*
* E (input) REAL array, dimension (N-1)
* The (n-1) subdiagonal elements of the unit bidiagonal factor
-* L from the L*D*L' factorization of A. E can also be regarded
+* L from the L*D*L**T factorization of A. E can also be regarded
* as the superdiagonal of the unit bidiagonal factor U from the
-* factorization A = U'*D*U.
+* factorization A = U**T*D*U.
*
* B (input/output) REAL array, dimension (LDB,NRHS)
* On entry, the right hand side vectors B for the system of
RETURN
END IF
*
-* Solve A * X = B using the factorization A = L*D*L',
+* Solve A * X = B using the factorization A = L*D*L**T,
* overwriting each right hand side vector with its solution.
*
DO 30 J = 1, NRHS
B( I, J ) = B( I, J ) - B( I-1, J )*E( I-1 )
10 CONTINUE
*
-* Solve D * L' * x = b.
+* Solve D * L**T * x = b.
*
B( N, J ) = B( N, J ) / D( N )
DO 20 I = N - 1, 1, -1
CALL SLACN2( N, WORK( N+1 ), WORK, IWORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**T) or inv(U*D*U**T).
*
CALL SSPTRS( UPLO, N, 1, AP, IPIV, WORK, N, INFO )
GO TO 30
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**T)*A*inv(U)
*
* J1 and JJ are the indices of A(1,j) and A(j,j)
*
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**T)
*
* KK and K1K1 are the indices of A(k,k) and A(k+1,k+1)
*
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**T
*
* K1 and KK are the indices of A(1,k) and A(k,k)
*
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**T *A*L
*
* JJ and J1J1 are the indices of A(j,j) and A(j+1,j+1)
*
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T*y
*
IF( UPPER ) THEN
TRANS = 'T'
END IF
WORK( 1 ) = LWMIN
IWORK( 1 ) = LIWMIN
-*
IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
INFO = -11
ELSE IF( LIWORK.LT.LIWMIN .AND. .NOT.LQUERY ) THEN
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T *y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T *y
*
IF( UPPER ) THEN
TRANS = 'T'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T*y
*
IF( UPPER ) THEN
TRANS = 'T'
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL SSPTRF( UPLO, N, AP, IPIV, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL SCOPY( N*( N+1 ) / 2, AP, 1, AFP, 1 )
CALL SSPTRF( UPLO, N, AFP, IPIV, INFO )
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in AP,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in AP,
I1 = N*( N-1 ) / 2 + 1
DO 10 I = N - 1, 1, -1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**T
* to annihilate A(1:i-1,i+1)
*
CALL SLARFG( I, AP( I1+I-1 ), AP( I1 ), 1, TAUI )
CALL SSPMV( UPLO, I, TAUI, AP, AP( I1 ), 1, ZERO, TAU,
$ 1 )
*
-* Compute w := y - 1/2 * tau * (y'*v) * v
+* Compute w := y - 1/2 * tau * (y**T *v) * v
*
ALPHA = -HALF*TAUI*SDOT( I, TAU, 1, AP( I1 ), 1 )
CALL SAXPY( I, ALPHA, AP( I1 ), 1, TAU, 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v'
+* A := A - v * w**T - w * v**T
*
CALL SSPR2( UPLO, I, -ONE, AP( I1 ), 1, TAU, 1, AP )
*
DO 20 I = 1, N - 1
I1I1 = II + N - I + 1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**T
* to annihilate A(i+2:n,i)
*
CALL SLARFG( N-I, AP( II+1 ), AP( II+2 ), 1, TAUI )
CALL SSPMV( UPLO, N-I, TAUI, AP( I1I1 ), AP( II+1 ), 1,
$ ZERO, TAU( I ), 1 )
*
-* Compute w := y - 1/2 * tau * (y'*v) * v
+* Compute w := y - 1/2 * tau * (y**T *v) * v
*
ALPHA = -HALF*TAUI*SDOT( N-I, TAU( I ), 1, AP( II+1 ),
$ 1 )
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'
+* A := A - v * w' - w * v**T
*
CALL SSPR2( UPLO, N-I, -ONE, AP( II+1 ), 1, TAU( I ), 1,
$ AP( I1I1 ) )
* 5-96 - Based on modifications by J. Lewis, Boeing Computer Services
* Company
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**T = A - W(k)*1/D(k)*W(k)**T
*
R1 = ONE / AP( KC+K-1 )
CALL SSPR( UPLO, K-1, -R1, AP( KC ), 1, AP )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**T
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**T
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**T = A - W(k)*(1/D(k))*W(k)**T
*
R1 = ONE / AP( KC )
CALL SSPR( UPLO, N-K, -R1, AP( KC+1 ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )'
-* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )'
+* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )**T
+* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )**T
+*
+* where L(k) and L(k+1) are the k-th and (k+1)-th
+* columns of L
*
D21 = AP( K+1+( K-1 )*( 2*N-K ) / 2 )
D11 = AP( K+1+K*( 2*N-K-1 ) / 2 ) / D21
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**T.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**T*X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**T(K)), where U(K) is the transformation
* stored in column K of A.
*
CALL SGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, AP( KC ),
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**T(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
CALL SGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, AP( KC ),
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**T.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**T*X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**T(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N )
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**T(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
CALL SLACN2( N, WORK( N+1 ), WORK, IWORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**T) or inv(U*D*U**T).
*
CALL SSYTRS( UPLO, N, 1, A, LDA, IPIV, WORK, N, INFO )
GO TO 30
* to standard form.
*
* If ITYPE = 1, the problem is A*x = lambda*B*x,
-* and A is overwritten by inv(U')*A*inv(U) or inv(L)*A*inv(L')
+* and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T)
*
* If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or
-* B*A*x = lambda*x, and A is overwritten by U*A*U` or L'*A*L.
+* B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T *A*L.
*
-* B must have been previously factorized as U'*U or L*L' by SPOTRF.
+* B must have been previously factorized as U**T *U or L*L**T by SPOTRF.
*
* Arguments
* =========
*
* ITYPE (input) INTEGER
-* = 1: compute inv(U')*A*inv(U) or inv(L)*A*inv(L');
-* = 2 or 3: compute U*A*U' or L'*A*L.
+* = 1: compute inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T);
+* = 2 or 3: compute U*A*U**T or L**T *A*L.
*
* UPLO (input) CHARACTER*1
* Specifies whether the upper or lower triangular part of the
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**T)*A*inv(U)
*
DO 10 K = 1, N
*
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**T)
*
DO 20 K = 1, N
*
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**T
*
DO 30 K = 1, N
*
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**T *A*L
*
DO 40 K = 1, N
*
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**T)*A*inv(U)
*
DO 10 K = 1, N, NB
KB = MIN( N-K+1, NB )
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**T)
*
DO 20 K = 1, N, NB
KB = MIN( N-K+1, NB )
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**T
*
DO 30 K = 1, N, NB
KB = MIN( N-K+1, NB )
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**T*A*L
*
DO 40 K = 1, N, NB
KB = MIN( N-K+1, NB )
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T*y
*
IF( UPPER ) THEN
TRANS = 'T'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T*y
*
IF( UPPER ) THEN
TRANS = 'T'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**T*y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**T*y
*
IF( UPPER ) THEN
TRANS = 'T'
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL SSYTRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL SLACPY( UPLO, N, N, A, LDA, AF, LDAF )
CALL SSYTRF( UPLO, N, AF, LDAF, IPIV, WORK, LWORK, INFO )
* =======
*
* SSYTD2 reduces a real symmetric matrix A to symmetric tridiagonal
-* form T by an orthogonal similarity transformation: Q' * A * Q = T.
+* form T by an orthogonal similarity transformation: Q**T * A * Q = T.
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i),
*
DO 10 I = N - 1, 1, -1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**T
* to annihilate A(1:i-1,i+1)
*
CALL SLARFG( I, A( I, I+1 ), A( 1, I+1 ), 1, TAUI )
CALL SSYMV( UPLO, I, TAUI, A, LDA, A( 1, I+1 ), 1, ZERO,
$ TAU, 1 )
*
-* Compute w := x - 1/2 * tau * (x'*v) * v
+* Compute w := x - 1/2 * tau * (x**T * v) * v
*
ALPHA = -HALF*TAUI*SDOT( I, TAU, 1, A( 1, I+1 ), 1 )
CALL SAXPY( I, ALPHA, A( 1, I+1 ), 1, TAU, 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v'
+* A := A - v * w**T - w * v**T
*
CALL SSYR2( UPLO, I, -ONE, A( 1, I+1 ), 1, TAU, 1, A,
$ LDA )
*
DO 20 I = 1, N - 1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**T
* to annihilate A(i+2:n,i)
*
CALL SLARFG( N-I, A( I+1, I ), A( MIN( I+2, N ), I ), 1,
CALL SSYMV( UPLO, N-I, TAUI, A( I+1, I+1 ), LDA,
$ A( I+1, I ), 1, ZERO, TAU( I ), 1 )
*
-* Compute w := x - 1/2 * tau * (x'*v) * v
+* Compute w := x - 1/2 * tau * (x**T * v) * v
*
ALPHA = -HALF*TAUI*SDOT( N-I, TAU( I ), 1, A( I+1, I ),
$ 1 )
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'
+* A := A - v * w' - w * v**T
*
CALL SSYR2( UPLO, N-I, -ONE, A( I+1, I ), 1, TAU( I ), 1,
$ A( I+1, I+1 ), LDA )
* SSYTF2 computes the factorization of a real symmetric matrix A using
* the Bunch-Kaufman diagonal pivoting method:
*
-* A = U*D*U' or A = L*D*L'
+* A = U*D*U**T or A = L*D*L**T
*
* where U (or L) is a product of permutation and unit upper (lower)
-* triangular matrices, U' is the transpose of U, and D is symmetric and
+* triangular matrices, U**T is the transpose of U, and D is symmetric and
* block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* 1-96 - Based on modifications by J. Lewis, Boeing Computer Services
* Company
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**T = A - W(k)*1/D(k)*W(k)**T
*
R1 = ONE / A( K, K )
CALL SSYR( UPLO, K-1, -R1, A( 1, K ), 1, A, LDA )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**T
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**T
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**T = A - W(k)*(1/D(k))*W(k)**T
*
D11 = ONE / A( K, K )
CALL SSYR( UPLO, N-K, -D11, A( K+1, K ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( (A(k) A(k+1))*D(k)**(-1) ) * (A(k) A(k+1))'
+* A := A - ( (A(k) A(k+1))*D(k)**(-1) ) * (A(k) A(k+1))**T
*
* where L(k) and L(k+1) are the k-th and (k+1)-th
* columns of L
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**T
*
* where tau is a real scalar, and v is a real vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i),
$ LDWORK )
*
* Update the unreduced submatrix A(1:i-1,1:i-1), using an
-* update of the form: A := A - V*W' - W*V'
+* update of the form: A := A - V*W' - 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'
+* an update of the form: A := A - V*W' - W*V**T
*
CALL SSYR2K( UPLO, 'No transpose', N-I-NB+1, NB, -ONE,
$ A( I+NB, I ), LDA, WORK( NB+1 ), LDWORK, ONE,
* Further Details
* ===============
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* KB, where KB is the number of columns factorized by SLASYF;
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* KB, where KB is the number of columns factorized by SLASYF;
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
IF( UPPER ) THEN
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
*
CALL STRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**T) = (inv(U))**T
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**T)*inv(D)*inv(U)
*
CUT=N
DO WHILE (CUT .GT. 0)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
*
CALL STRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**T) = (inv(U))**T
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**T)*inv(D)*inv(U)
*
CUT=0
DO WHILE (CUT .LT. N)
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
*
I=N
DO WHILE ( I .GE. 1 )
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**T.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**T *X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**T(K)), where U(K) is the transformation
* stored in column K of A.
*
CALL SGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, A( 1, K ),
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**T(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
CALL SGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, A( 1, K ),
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**T.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**T *X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**T(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N )
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**T(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
SUBROUTINE SSYTRS2( UPLO, N, NRHS, A, LDA, IPIV, B, LDB,
$ WORK, INFO )
*
-* -- LAPACK PROTOTYPE routine (version 3.2.2) --
-*
-* -- Written by Julie Langou of the Univ. of TN --
-* May 2010
-*
+* -- LAPACK PROTOTYPE routine (version 3.3.0) --
* -- LAPACK is a software package provided by Univ. of Tennessee, --
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
+* November 2010
+*
+* -- Written by Julie Langou of the Univ. of TN --
*
* .. Scalar Arguments ..
CHARACTER UPLO
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**T.
*
* P' * B
K=N
END IF
END DO
*
-* Compute (U \P' * B) -> B [ (U \P' * B) ]
+* Compute (U \P**T * B) -> B [ (U \P**T * B) ]
*
CALL STRSM('L','U','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (U \P' * B) ]
+* Compute D \ B -> B [ D \ (U \P**T * B) ]
*
I=N
DO WHILE ( I .GE. 1 )
I = I - 1
END DO
*
-* Compute (U' \ B) -> B [ U' \ (D \ (U \P' * B) ) ]
+* Compute (U**T \ B) -> B [ U**T \ (D \ (U \P**T * B) ) ]
*
CALL STRSM('L','U','T','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (U' \ (D \ (U \P' * B) )) ]
+* P * B [ P * (U**T \ (D \ (U \P**T * B) )) ]
*
K=1
DO WHILE ( K .LE. N )
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**T.
*
* P' * B
K=1
ENDIF
END DO
*
-* Compute (L \P' * B) -> B [ (L \P' * B) ]
+* Compute (L \P**T * B) -> B [ (L \P**T * B) ]
*
CALL STRSM('L','L','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (L \P' * B) ]
+* Compute D \ B -> B [ D \ (L \P**T * B) ]
*
I=1
DO WHILE ( I .LE. N )
I = I + 1
END DO
*
-* Compute (L' \ B) -> B [ L' \ (D \ (L \P' * B) ) ]
+* Compute (L**T \ B) -> B [ L**T \ (D \ (L \P**T * B) ) ]
*
CALL STRSM('L','L','T','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (L' \ (D \ (L \P' * B) )) ]
+* P * B [ P * (L**T \ (D \ (L \P**T * B) )) ]
*
K=N
DO WHILE ( K .GE. 1 )
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(op(A)').
+* Multiply by diag(W)*inv(op(A)**T).
*
CALL STBSV( UPLO, TRANST, DIAG, N, KD, AB, LDAB,
$ WORK( N+1 ), 1 )
* Optionally, the matrices Q and Z of generalized Schur vectors are
* updated.
*
-* Q(in) * A(in) * Z(in)' = Q(out) * A(out) * Z(out)'
-* Q(in) * B(in) * Z(in)' = Q(out) * B(out) * Z(out)'
+* Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T
+* Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T
*
*
* Arguments
IF( WANDS ) THEN
*
* Strong stability test:
-* F-norm((A-QL'*S*QR, B-QL'*T*QR)) <= O(EPS*F-norm((A,B)))
+* F-norm((A-QL**T*S*QR, B-QL**T*T*QR)) <= O(EPS*F-norm((A, B)))
*
CALL SLACPY( 'Full', M, M, A( J1, J1 ), LDA, WORK( M*M+1 ),
$ M )
*
* Compute orthogonal matrix QL:
*
-* QL' * LI = [ TL ]
-* [ 0 ]
+* QL**T * LI = [ TL ]
+* [ 0 ]
* where
* LI = [ -L ]
* [ SCALE * identity(N2) ]
*
* Compute orthogonal matrix RQ:
*
-* IR * RQ' = [ 0 TR],
+* IR * RQ**T = [ 0 TR],
*
* where IR = [ SCALE * identity(N1), R ]
*
IF( WANDS ) THEN
*
* Strong stability test:
-* F-norm((A-QL*S*QR', B-QL*T*QR')) <= O(EPS*F-norm((A,B)))
+* F-norm((A-QL*S*QR**T, B-QL*T*QR**T)) <= O(EPS*F-norm((A,B)))
*
CALL SLACPY( 'Full', M, M, A( J1, J1 ), LDA, WORK( M*M+1 ),
$ M )
* Optionally, the matrices Q and Z of generalized Schur vectors are
* updated.
*
-* Q(in) * A(in) * Z(in)' = Q(out) * A(out) * Z(out)'
-* Q(in) * B(in) * Z(in)' = Q(out) * B(out) * Z(out)'
+* Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T
+* Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T
*
*
* Arguments
*
* STGSEN reorders the generalized real Schur decomposition of a real
* matrix pair (A, B) (in terms of an orthonormal equivalence trans-
-* formation Q' * (A, B) * Z), so that a selected cluster of eigenvalues
+* formation Q**T * (A, B) * Z), so that a selected cluster of eigenvalues
* appears in the leading diagonal blocks of the upper quasi-triangular
* matrix A and the upper triangular B. The leading columns of Q and
* Z form orthonormal bases of the corresponding left and right eigen-
* In other words, the selected eigenvalues are the eigenvalues of
* (A11, B11) in:
*
-* U'*(A, B)*W = (A11 A12) (B11 B12) n1
+* U**T*(A, B)*W = (A11 A12) (B11 B12) n1
* ( 0 A22),( 0 B22) n2
* n1 n2 n1 n2
*
* (deflating subspaces) of (A, B).
*
* If (A, B) has been obtained from the generalized real Schur
-* decomposition of a matrix pair (C, D) = Q*(A, B)*Z', then the
+* decomposition of a matrix pair (C, D) = Q*(A, B)*Z**T, then the
* reordered generalized real Schur form of (C, D) is given by
*
-* (C, D) = (Q*U)*(U'*(A, B)*W)*(Z*W)',
+* (C, D) = (Q*U)*(U**T*(A, B)*W)*(Z*W)**T,
*
* and the first n1 columns of Q*U and Z*W span the corresponding
* deflating subspaces of (C, D) (Q and Z store Q*U and Z*W, resp.).
* 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**T, In1) ]
+* [ kron(In2, B11) -kron(B22**T, In1) ].
*
-* Here, Inx is the identity matrix of size nx and A22' is the
+* Here, Inx is the identity matrix of size nx and A22**T is the
* transpose of A22. kron(X, Y) is the Kronecker product between
* the matrices X and Y.
*
*
* On exit,
*
-* U'*A*Q = D1*( 0 R ), V'*B*Q = D2*( 0 R ),
+* U**T *A*Q = D1*( 0 R ), V**T *B*Q = D2*( 0 R ),
*
-* where U, V and Q are orthogonal matrices, Z' denotes the transpose
-* of Z, R is a nonsingular upper triangular matrix, and D1 and D2 are
+* where U, V and Q are orthogonal matrices.
+* R is a nonsingular upper triangular matrix, and D1 and D2 are
* ``diagonal'' matrices, which are of the following structures:
*
* If M-K-L >= 0,
* min(L,M-K)-by-L triangular (or trapezoidal) matrix A23 and L-by-L
* matrix B13 to the form:
*
-* U1'*A13*Q1 = C1*R1; V1'*B13*Q1 = S1*R1,
+* 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
* of Z. C1 and S1 are diagonal matrices satisfying
CALL SLAGS2( UPPER, A1, A2, A3, B1, B2, B3, CSU, SNU,
$ CSV, SNV, CSQ, SNQ )
*
-* Update (K+I)-th and (K+J)-th rows of matrix A: U'*A
+* Update (K+I)-th and (K+J)-th rows of matrix A: U**T *A
*
IF( K+J.LE.M )
$ CALL SROT( L, A( K+J, N-L+1 ), LDA, A( K+I, N-L+1 ),
$ LDA, CSU, SNU )
*
-* Update I-th and J-th rows of matrix B: V'*B
+* Update I-th and J-th rows of matrix B: V**T *B
*
CALL SROT( L, B( J, N-L+1 ), LDB, B( I, N-L+1 ), LDB,
$ CSV, SNV )
* STGSNA estimates reciprocal condition numbers for specified
* eigenvalues and/or eigenvectors of a matrix pair (A, B) in
* generalized real Schur canonical form (or of any matrix pair
-* (Q*A*Z', Q*B*Z') with orthogonal matrices Q and Z, where
+* (Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where
* Z' denotes the transpose of Z.
*
* (A, B) must be in generalized real Schur form (as returned by SGGES),
* The reciprocal of the condition number of a generalized eigenvalue
* w = (a, b) is defined as
*
-* S(w) = (|u'Av|**2 + |u'Bv|**2)**(1/2) / (norm(u)*norm(v))
+* S(w) = (|u**TAv|**2 + |u**TBv|**2)**(1/2) / (norm(u)*norm(v))
*
* where u and v are the left and right eigenvectors of (A, B)
* corresponding to w; |z| denotes the absolute value of the complex
* number, and norm(u) denotes the 2-norm of the vector u.
-* The pair (a, b) corresponds to an eigenvalue w = a/b (= u'Av/u'Bv)
+* The pair (a, b) corresponds to an eigenvalue w = a/b (= u**TAv/u**TBv)
* of the matrix pair (A, B). If both a and b equal zero, then (A B) is
* singular and S(I) = -1 is returned.
*
*
* Suppose U and V are orthogonal transformations such that
*
-* U'*(A, B)*V = (S, T) = ( a * ) ( b * ) 1
+* U**T*(A, B)*V = (S, T) = ( a * ) ( b * ) 1
* ( 0 S22 ),( 0 T22 ) n-1
* 1 n-1 1 n-1
*
*
* Suppose U and V are orthogonal transformations such that
*
-* U'*(A, B)*V = (S, T) = ( S11 * ) ( T11 * ) 2
+* U**T*(A, B)*V = (S, T) = ( S11 * ) ( T11 * ) 2
* ( 0 S22 ),( 0 T22) n-2
* 2 n-2 2 n-2
*
* pair (w, conjg(w)). There exist unitary matrices U1 and V1 such
* that
*
-* U1'*S11*V1 = ( s11 s12 ) and U1'*T11*V1 = ( t11 t12 )
+* U1**T*S11*V1 = ( s11 s12 ) and U1**T*T11*V1 = ( t11 t12 )
* ( 0 s22 ) ( 0 t22 )
*
* where the generalized eigenvalues w = s11/t11 and
* [ t11 -t22 ],
*
* This is done by computing (using real arithmetic) the
-* roots of the characteristical polynomial det(Z1' * Z1 - lambda I),
-* where Z1' denotes the conjugate transpose of Z1 and det(X) denotes
+* roots of the characteristical polynomial det(Z1**T * Z1 - lambda I),
+* where Z1**T denotes the transpose of Z1 and det(X) denotes
* the determinant of X.
*
* and d2 is an upper bound on Difl((S11, T11), (S22, T22)), i.e. an
ELSE
*
* Solve (I, J) - subsystem
-* A(I, I)' * R(I, J) + D(I, I)' * L(J, J) = C(I, J)
+* A(I, I)**T * R(I, J) + D(I, I)**T * L(J, J) = C(I, J)
* R(I, I) * B(J, J) + L(I, J) * E(J, J) = -F(I, J)
* for I = 1, 2, ..., P, J = Q, Q - 1, ..., 1
*
* Here Ik is the identity matrix of size k and X' 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'*y = scale*b,
+* If TRANS = 'T', STGSYL solves the transposed system Z**T*y = scale*b,
* 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 (TRANS = 'T') is used to compute an one-norm-based estimate
* of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D)
ELSE
*
* Solve transposed (I, J)-subsystem
-* A(I, I)' * R(I, J) + D(I, I)' * L(I, J) = C(I, J)
-* R(I, J) * B(J, J)' + L(I, J) * E(J, J)' = -F(I, J)
+* A(I, I)**T * R(I, J) + D(I, I)**T * L(I, J) = C(I, J)
+* R(I, J) * B(J, J)**T + L(I, J) * E(J, J)**T = -F(I, J)
* for I = 1,2,..., P; J = Q, Q-1,..., 1
*
SCALE = ONE
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(op(A)').
+* Multiply by diag(W)*inv(op(A)**T).
*
CALL STPSV( UPLO, TRANST, DIAG, N, AP, WORK( N+1 ), 1 )
DO 220 I = 1, N
* The right eigenvector x and the left eigenvector y of T corresponding
* to an eigenvalue w are defined by:
*
-* T*x = w*x, (y**H)*T = w*(y**H)
+* T*x = w*x, (y**T)*T = w*(y**T)
*
-* where y**H denotes the conjugate transpose of y.
+* where y**T denotes the transpose of y.
* The eigenvalues are not input to this routine, but are read directly
* from the diagonal blocks of T.
*
160 CONTINUE
*
* Solve the quasi-triangular system:
-* (T(KI+1:N,KI+1:N) - WR)'*X = SCALE*WORK
+* (T(KI+1:N,KI+1:N) - WR)**T*X = SCALE*WORK
*
VMAX = ONE
VCRIT = BIGNUM
$ SDOT( J-KI-1, T( KI+1, J ), 1,
$ WORK( KI+1+N ), 1 )
*
-* Solve (T(J,J)-WR)'*X = WORK
+* Solve (T(J,J)-WR)**T*X = WORK
*
CALL SLALN2( .FALSE., 1, 1, SMIN, ONE, T( J, J ),
$ LDT, ONE, ONE, WORK( J+N ), N, WR,
* Complex left eigenvector.
*
* Initial solve:
-* ((T(KI,KI) T(KI,KI+1) )' - (WR - I* WI))*X = 0.
+* ((T(KI,KI) T(KI,KI+1) )**T - (WR - I* WI))*X = 0.
* ((T(KI+1,KI) T(KI+1,KI+1)) )
*
IF( ABS( T( KI, KI+1 ) ).GE.ABS( T( KI+1, KI ) ) ) THEN
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Multiply by diag(W)*inv(op(A)').
+* Multiply by diag(W)*inv(op(A)**T).
*
CALL STRSV( UPLO, TRANST, DIAG, N, A, LDA, WORK( N+1 ),
$ 1 )
* In other words, the selected eigenvalues are the eigenvalues of T11
* in:
*
-* Z'*T*Z = ( T11 T12 ) n1
+* Z**T * T * Z = ( T11 T12 ) n1
* ( 0 T22 ) n2
* n1 n2
*
* of Z span the specified invariant subspace of T.
*
* If T has been obtained from the real Schur factorization of a matrix
-* A = Q*T*Q', then the reordered real Schur factorization of A is given
-* by A = (Q*Z)*(Z'*T*Z)*(Q*Z)', and the first n1 columns of Q*Z span
+* A = Q*T*Q**T, then the reordered real Schur factorization of A is given
+* by A = (Q*Z)*(Z**T*T*Z)*(Q*Z)**T, and the first n1 columns of Q*Z span
* the corresponding invariant subspace of A.
*
* The reciprocal condition number of the average of the eigenvalues of
$ IERR )
ELSE
*
-* Solve T11'*R - R*T22' = scale*X.
+* Solve T11**T*R - R*T22**T = scale*X.
*
CALL STRSYL( 'T', 'T', -1, N1, N2, T, LDT,
$ T( N1+1, N1+1 ), LDT, WORK, N1, SCALE,
* The reciprocal of the condition number of an eigenvalue lambda is
* defined as
*
-* S(lambda) = |v'*u| / (norm(u)*norm(v))
+* S(lambda) = |v**T*u| / (norm(u)*norm(v))
*
* where u and v are the right and left eigenvectors of T corresponding
-* to lambda; v' denotes the conjugate-transpose of v, and norm(u)
+* to lambda; v**T denotes the transpose of v, and norm(u)
* denotes the Euclidean norm. These reciprocal condition numbers always
* lie between zero (very badly conditioned) and one (very well
* conditioned). If n = 1, S(lambda) is defined to be 1.
*
* Form
*
-* C' = WORK(2:N,2:N) + i*[rwork(1) ..... rwork(n-1) ]
-* [ mu ]
-* [ .. ]
-* [ .. ]
-* [ mu ]
-* where C' is conjugate transpose of complex matrix C,
+* C**T = WORK(2:N,2:N) + i*[rwork(1) ..... rwork(n-1) ]
+* [ mu ]
+* [ .. ]
+* [ .. ]
+* [ mu ]
+* where C**T is transpose of matrix C,
* and RWORK is stored starting in the N+1-st column of
* WORK.
*
NN = 2*( N-1 )
END IF
*
-* Estimate norm(inv(C'))
+* Estimate norm(inv(C**T))
*
EST = ZERO
KASE = 0
IF( KASE.EQ.1 ) THEN
IF( N2.EQ.1 ) THEN
*
-* Real eigenvalue: solve C'*x = scale*c.
+* Real eigenvalue: solve C**T*x = scale*c.
*
CALL SLAQTR( .TRUE., .TRUE., N-1, WORK( 2, 2 ),
$ LDWORK, DUMMY, DUMM, SCALE,
ELSE
*
* Complex eigenvalue: solve
-* C'*(p+iq) = scale*(c+id) in real arithmetic.
+* C**T*(p+iq) = scale*(c+id) in real arithmetic.
*
CALL SLAQTR( .TRUE., .FALSE., N-1, WORK( 2, 2 ),
$ LDWORK, WORK( 1, N+1 ), MU, SCALE,
*
ELSE IF( .NOT.NOTRNA .AND. NOTRNB ) THEN
*
-* Solve A' *X + ISGN*X*B = scale*C.
+* Solve A**T *X + ISGN*X*B = scale*C.
*
* The (K,L)th block of X is determined starting from
* upper-left corner column by column by
*
-* A(K,K)'*X(K,L) + ISGN*X(K,L)*B(L,L) = C(K,L) - R(K,L)
+* A(K,K)**T*X(K,L) + ISGN*X(K,L)*B(L,L) = C(K,L) - R(K,L)
*
* Where
-* K-1 L-1
-* R(K,L) = SUM [A(I,K)'*X(I,L)] +ISGN*SUM [X(K,J)*B(J,L)]
-* I=1 J=1
+* K-1 L-1
+* R(K,L) = SUM [A(I,K)**T*X(I,L)] +ISGN*SUM [X(K,J)*B(J,L)]
+* I=1 J=1
*
* Start column loop (index = L)
* L1 (L2): column index of the first (last) row of X(K,L)
*
ELSE IF( .NOT.NOTRNA .AND. .NOT.NOTRNB ) THEN
*
-* Solve A'*X + ISGN*X*B' = scale*C.
+* Solve A**T*X + ISGN*X*B**T = scale*C.
*
* The (K,L)th block of X is determined starting from
* top-right corner column by column by
*
-* A(K,K)'*X(K,L) + ISGN*X(K,L)*B(L,L)' = C(K,L) - R(K,L)
+* A(K,K)**T*X(K,L) + ISGN*X(K,L)*B(L,L)**T = C(K,L) - R(K,L)
*
* Where
-* K-1 N
-* R(K,L) = SUM [A(I,K)'*X(I,L)] + ISGN*SUM [X(K,J)*B(L,J)'].
-* I=1 J=L+1
+* K-1 N
+* R(K,L) = SUM [A(I,K)**T*X(I,L)] + ISGN*SUM [X(K,J)*B(L,J)**T].
+* I=1 J=L+1
*
* Start column loop (index = L)
* L1 (L2): column index of the first (last) row of X(K,L)
*
ELSE IF( NOTRNA .AND. .NOT.NOTRNB ) THEN
*
-* Solve A*X + ISGN*X*B' = scale*C.
+* Solve A*X + ISGN*X*B**T = scale*C.
*
* The (K,L)th block of X is determined starting from
* bottom-right corner column by column by
*
-* A(K,K)*X(K,L) + ISGN*X(K,L)*B(L,L)' = C(K,L) - R(K,L)
+* A(K,K)*X(K,L) + ISGN*X(K,L)*B(L,L)**T = C(K,L) - R(K,L)
*
* Where
* M N
-* R(K,L) = SUM [A(K,I)*X(I,L)] + ISGN*SUM [X(K,J)*B(L,J)'].
+* R(K,L) = SUM [A(K,I)*X(I,L)] + ISGN*SUM [X(K,J)*B(L,J)**T].
* I=K+1 J=L+1
*
* Start column loop (index = L)
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
-* ( 0 )
-* ( z( k ) )
+* T( k ) = I - tau*u( k )*u( k )**T, u( k ) = ( 1 ),
+* ( 0 )
+* ( z( k ) )
*
* tau is a scalar and z( k ) is an ( n - m ) element vector.
* tau and z( k ) are chosen to annihilate the elements of the kth row
$ LDA, A( K, M1 ), LDA, ONE, TAU, 1 )
*
* Now form a( k ) := a( k ) - tau*w
-* and B := B - tau*w*z( k )'.
+* and B := B - tau*w*z( k )**T.
*
CALL SAXPY( K-1, -TAU( K ), TAU, 1, A( 1, K ), 1 )
CALL SGER( K-1, N-M, -TAU( K ), TAU, 1, A( K, M1 ), LDA,
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
+* T( k ) = I - tau*u( k )*u( k )**T, u( k ) = ( 1 ),
* ( 0 )
* ( z( k ) )
*
* =======
*
* ZGBBRD reduces a complex general m-by-n band matrix A to real upper
-* bidiagonal form B by a unitary transformation: Q' * A * P = B.
+* bidiagonal form B by a unitary transformation: Q**H * A * P = B.
*
-* The routine computes B, and optionally forms Q or P', or computes
-* Q'*C for a given matrix C.
+* The routine computes B, and optionally forms Q or P**H, or computes
+* Q**H*C for a given matrix C.
*
* Arguments
* =========
*
* VECT (input) CHARACTER*1
-* Specifies whether or not the matrices Q and P' are to be
+* Specifies whether or not the matrices Q and P**H are to be
* formed.
-* = 'N': do not form Q or P';
+* = 'N': do not form Q or P**H;
* = 'Q': form Q only;
-* = 'P': form P' only;
+* = 'P': form P**H only;
* = 'B': form both.
*
* M (input) INTEGER
*
* C (input/output) COMPLEX*16 array, dimension (LDC,NCC)
* On entry, an m-by-ncc matrix C.
-* On exit, C is overwritten by Q'*C.
+* On exit, C is overwritten by Q**H*C.
* C is not referenced if NCC = 0.
*
* LDC (input) INTEGER
RETURN
END IF
*
-* Initialize Q and P' to the unit matrix, if needed
+* Initialize Q and P**H to the unit matrix, if needed
*
IF( WANTQ )
$ CALL ZLASET( 'Full', M, M, CZERO, CONE, Q, LDQ )
*
IF( WANTPT ) THEN
*
-* accumulate product of plane rotations in P'
+* accumulate product of plane rotations in P**H
*
DO 60 J = J1, J2, KB1
CALL ZROT( N, PT( J+KUN-1, 1 ), LDPT,
$ KL+KU, AB, LDAB, WORK, SCALE, RWORK, INFO )
ELSE
*
-* Multiply by inv(U').
+* Multiply by inv(U**H).
*
CALL ZLATBS( 'Upper', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, KL+KU, AB, LDAB, WORK, SCALE, RWORK,
$ INFO )
*
-* Multiply by inv(L').
+* Multiply by inv(L**H).
*
IF( LNOTI ) THEN
DO 30 J = N - 1, 1, -1
* =======
*
* ZGEBD2 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.
*
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**H and G(i) = I - taup * u * u**H
*
* where tauq and taup are complex scalars, and v and u are complex
* vectors; v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**H and G(i) = I - taup * u * u**H
*
* where tauq and taup are complex scalars, v and u are complex vectors;
* v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in A(i+2:m,i);
D( I ) = ALPHA
A( I, I ) = ONE
*
-* Apply H(i)' to A(i:m,i+1:n) from the left
+* Apply H(i)**H to A(i:m,i+1:n) from the left
*
IF( I.LT.N )
$ CALL ZLARF( 'Left', M-I+1, N-I, A( I, I ), 1,
E( I ) = ALPHA
A( I+1, I ) = ONE
*
-* Apply H(i)' to A(i+1:m,i+1:n) from the left
+* Apply H(i)**H to A(i+1:m,i+1:n) from the left
*
CALL ZLARF( 'Left', M-I, N-I, A( I+1, I ), 1,
$ DCONJG( TAUQ( I ) ), A( I+1, I+1 ), LDA,
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**H and G(i) = I - taup * u * u**H
*
* where tauq and taup are complex scalars, and v and u are complex
* vectors; v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**H and G(i) = I - taup * u * u**H
*
* where tauq and taup are complex scalars, and v and u are complex
* vectors; v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in
$ WORK( LDWRKX*NB+1 ), LDWRKY )
*
* Update the trailing submatrix A(i+ib:m,i+ib:n), using
-* an update of the form A := A - V*Y' - X*U'
+* an update of the form A := A - V*Y**H - X*U**H
*
CALL ZGEMM( 'No transpose', 'Conjugate transpose', M-I-NB+1,
$ N-I-NB+1, NB, -ONE, A( I+NB, I ), LDA,
$ A, LDA, WORK, SU, RWORK( N+1 ), INFO )
ELSE
*
-* Multiply by inv(U').
+* Multiply by inv(U**H).
*
CALL ZLATRS( 'Upper', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, A, LDA, WORK, SU, RWORK( N+1 ),
$ INFO )
*
-* Multiply by inv(L').
+* Multiply by inv(L**H).
*
CALL ZLATRS( 'Lower', 'Conjugate transpose', 'Unit', NORMIN,
$ N, A, LDA, WORK, SL, RWORK, INFO )
* =======
*
* ZGEHD2 reduces a complex general matrix A to upper Hessenberg form H
-* by a unitary similarity transformation: Q' * A * Q = H .
+* by a unitary similarity transformation: Q**H * A * Q = H .
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on
CALL ZLARF( 'Right', IHI, IHI-I, A( I+1, I ), 1, TAU( I ),
$ A( 1, I+1 ), LDA, WORK )
*
-* Apply H(i)' to A(i+1:ihi,i+1:n) from the left
+* Apply H(i)**H to A(i+1:ihi,i+1:n) from the left
*
CALL ZLARF( 'Left', IHI-I, N-I, A( I+1, I ), 1,
$ DCONJG( TAU( I ) ), A( I+1, I+1 ), LDA, WORK )
* =======
*
* ZGEHRD reduces a complex general matrix A to upper Hessenberg form H by
-* an unitary similarity transformation: Q' * A * Q = H .
+* an unitary similarity transformation: Q**H * A * Q = H .
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0, v(i+1) = 1 and v(ihi+1:n) = 0; v(i+2:ihi) is stored on
IB = MIN( NB, IHI-I )
*
* Reduce columns i:i+ib-1 to Hessenberg form, returning the
-* matrices V and T of the block reflector H = I - V*T*V'
+* matrices V and T of the block reflector H = I - V*T*V**H
* which performs the reduction, and also the matrix Y = A*V*T
*
CALL ZLAHR2( IHI, I, IB, A( 1, I ), LDA, TAU( I ), T, LDT,
$ WORK, LDWORK )
*
* Apply the block reflector H to A(1:ihi,i+ib:ihi) from the
-* right, computing A := A - Y * V'. V(i+ib,ib-1) must be set
+* right, computing A := A - Y * V**H. V(i+ib,ib-1) must be set
* to 1
*
EI = A( I+IB, I+IB-1 )
*
* The matrix Q is represented as a product of elementary reflectors
*
-* Q = H(k)' . . . H(2)' H(1)', where k = min(m,n).
+* Q = H(k)**H . . . H(2)**H H(1)**H, where k = min(m,n).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; conjg(v(i+1:n)) is stored on exit in
*
* The matrix Q is represented as a product of elementary reflectors
*
-* Q = H(k)' . . . H(2)' H(1)', where k = min(m,n).
+* Q = H(k)**H . . . H(2)**H H(1)**H, where k = min(m,n).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; conjg(v(i+1:n)) is stored on exit in
*
* Least-Squares Problem min || A * X - B ||
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**H * B(1:M,1:NRHS)
*
CALL ZUNMQR( 'Left', 'Conjugate transpose', M, NRHS, N, A,
$ LDA, WORK( 1 ), B, LDB, WORK( MN+1 ), LWORK-MN,
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Q(1:N,:)' * B(1:M,1:NRHS)
+* B(1:N,1:NRHS) := Q(1:N,:)**H * B(1:M,1:NRHS)
*
CALL ZUNMLQ( 'Left', 'Conjugate transpose', N, NRHS, M, A,
$ LDA, WORK( 1 ), B, LDB, WORK( MN+1 ), LWORK-MN,
* 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.
*
* Arguments
*
* Details of Householder rotations stored in WORK(MN+1:2*MN)
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**H * B(1:M,1:NRHS)
*
CALL ZUNM2R( 'Left', 'Conjugate transpose', M, NRHS, MN, A, LDA,
$ WORK( 1 ), B, LDB, WORK( 2*MN+1 ), INFO )
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Y' * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := Y**H * B(1:N,1:NRHS)
*
IF( RANK.LT.N ) THEN
DO 50 I = 1, RANK
* 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
* complex workspace: 2*MN.
* Details of Householder rotations stored in WORK(MN+1:2*MN)
*
-* B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS)
+* B(1:M,1:NRHS) := Q**H * B(1:M,1:NRHS)
*
CALL ZUNMQR( 'Left', 'Conjugate transpose', M, NRHS, MN, A, LDA,
$ WORK( 1 ), B, LDB, WORK( 2*MN+1 ), LWORK-2*MN, INFO )
30 CONTINUE
40 CONTINUE
*
-* B(1:N,1:NRHS) := Y' * B(1:N,1:NRHS)
+* B(1:N,1:NRHS) := Y**H * B(1:N,1:NRHS)
*
IF( RANK.LT.N ) THEN
CALL ZUNMRZ( 'Left', 'Conjugate transpose', N, NRHS, RANK,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in
ALPHA = A( M-K+I, N-K+I )
CALL ZLARFG( M-K+I, ALPHA, A( 1, N-K+I ), 1, TAU( I ) )
*
-* Apply H(i)' to A(1:m-k+i,1:n-k+i-1) from the left
+* Apply H(i)**H to A(1:m-k+i,1:n-k+i-1) from the left
*
A( M-K+I, N-K+I ) = ONE
CALL ZLARF( 'Left', M-K+I, N-K+I-1, A( 1, N-K+I ), 1,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(m-k+i+1:m) = 0 and v(m-k+i) = 1; v(1:m-k+i-1) is stored on exit in
CALL ZLARFT( 'Backward', 'Columnwise', M-K+I+IB-1, IB,
$ A( 1, N-K+I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(1:m-k+i+ib-1,1:n-k+i-1) from the left
+* Apply H**H to A(1:m-k+i+ib-1,1:n-k+i-1) from the left
*
CALL ZLARFB( 'Left', 'Conjugate transpose', 'Backward',
$ 'Columnwise', M-K+I+IB-1, N-K+I-1, IB,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a real/complex scalar, and v is a real/complex vector
* with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in
*
* Each H(i) has the form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
$ TAU( I ) )
IF( I.LT.N ) THEN
*
-* Apply H(i)' to A(i:m,i+1:n) from the left
+* Apply H(i)**H to A(i:m,i+1:n) from the left
*
ALPHA = A( I, I )
A( I, I ) = ONE
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
$ TAU( I ) )
IF( I.LT.N ) THEN
*
-* Apply H(i)' to A(i:m,i+1:n) from the left
+* Apply H(i)**H to A(i:m,i+1:n) from the left
*
ALPHA = A( I, I )
A( I, I ) = ONE
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
CALL ZLARFT( 'Forward', 'Columnwise', M-I+1, IB,
$ A( I, I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i:m,i+ib:n) from the left
+* Apply H**H to A(i:m,i+ib:n) from the left
*
CALL ZLARFB( 'Left', 'Conjugate transpose', 'Forward',
$ 'Columnwise', M-I+1, N-I-IB+1, IB,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i),
CALL ZLARFT( 'Forward', 'Columnwise', M-I+1, IB,
$ A( I, I ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i:m,i+ib:n) from the left
+* Apply H**H to A(i:m,i+ib:n) from the left
*
CALL ZLARFB( 'Left', 'Conjugate transpose', 'Forward',
$ 'Columnwise', M-I+1, N-I-IB+1, IB,
*
* The matrix Q is represented as a product of elementary reflectors
*
-* Q = H(1)' H(2)' . . . H(k)', where k = min(m,n).
+* Q = H(1)**H H(2)**H . . . H(k)**H, where k = min(m,n).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; conjg(v(1:n-k+i-1)) is stored on
*
* The matrix Q is represented as a product of elementary reflectors
*
-* Q = H(1)' H(2)' . . . H(k)', where k = min(m,n).
+* Q = H(1)**H H(2)**H . . . H(k)**H, where k = min(m,n).
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; conjg(v(1:n-k+i-1)) is stored on
*
* Solve A**T * X = B or A**H * X = B.
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**T *X = B or U**H *X = B, overwriting B with X.
*
CALL ZTRSM( 'Left', 'Upper', TRANS, 'Non-unit', N, NRHS, ONE,
$ A, LDA, B, LDB )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**T *X = B, or L**H *X = B overwriting B with X.
*
CALL ZTRSM( 'Left', 'Lower', TRANS, 'Unit', N, NRHS, ONE, A,
$ LDA, B, LDB )
*
* Compute the GQR factorization of matrices A and B:
*
-* Q'*A = ( R11 ) M, Q'*B*Z' = ( T11 T12 ) M
-* ( 0 ) N-M ( 0 T22 ) N-M
-* M M+P-N N-M
+* Q**H*A = ( R11 ) M, Q**H*B*Z**H = ( T11 T12 ) M
+* ( 0 ) N-M ( 0 T22 ) N-M
+* M M+P-N N-M
*
* where R11 and T22 are upper triangular, and Q and Z are
* unitary.
$ WORK( M+NP+1 ), LWORK-M-NP, INFO )
LOPT = WORK( M+NP+1 )
*
-* Update left-hand-side vector d = Q'*d = ( d1 ) M
-* ( d2 ) N-M
+* Update left-hand-side vector d = Q**H*d = ( d1 ) M
+* ( d2 ) N-M
*
CALL ZUNMQR( 'Left', 'Conjugate transpose', N, 1, M, A, LDA, WORK,
$ D, MAX( 1, N ), WORK( M+NP+1 ), LWORK-M-NP, INFO )
CALL ZCOPY( M, D, 1, X, 1 )
END IF
*
-* Backward transformation y = Z'*y
+* Backward transformation y = Z**H *y
*
CALL ZUNMRQ( 'Left', 'Conjugate transpose', P, 1, NP,
$ B( MAX( 1, N-P+1 ), 1 ), LDB, WORK( M+1 ), Y,
* M-vector, and d is a given P-vector. It is assumed that
* P <= N <= M+P, and
*
-* rank(B) = P and rank( ( A ) ) = N.
-* ( ( B ) )
+* rank(B) = P and rank( (A) ) = N.
+* ( (B) )
*
* These conditions ensure that the LSE problem has a unique solution,
* which is obtained using a generalized RQ factorization of the
*
* Compute the GRQ factorization of matrices B and A:
*
-* B*Q' = ( 0 T12 ) P Z'*A*Q' = ( R11 R12 ) N-P
-* N-P P ( 0 R22 ) M+P-N
-* N-P P
+* B*Q**H = ( 0 T12 ) P Z**H*A*Q**H = ( R11 R12 ) N-P
+* N-P P ( 0 R22 ) M+P-N
+* N-P P
*
* where T12 and R11 are upper triangular, and Q and Z are
* unitary.
$ WORK( P+MN+1 ), LWORK-P-MN, INFO )
LOPT = WORK( P+MN+1 )
*
-* Update c = Z'*c = ( c1 ) N-P
+* Update c = Z**H *c = ( c1 ) N-P
* ( c2 ) M+P-N
*
CALL ZUNMQR( 'Left', 'Conjugate Transpose', M, 1, MN, A, LDA,
CALL ZAXPY( NR, -CONE, D, 1, C( N-P+1 ), 1 )
END IF
*
-* Backward transformation x = Q'*x
+* Backward transformation x = Q**H*x
*
CALL ZUNMRQ( 'Left', 'Conjugate Transpose', N, 1, P, B, LDB,
$ WORK( 1 ), X, N, WORK( P+MN+1 ), LWORK-P-MN, INFO )
* In particular, if B is square and nonsingular, the GQR factorization
* of A and B implicitly gives the QR factorization of inv(B)*A:
*
-* inv(B)*A = Z'*(inv(T)*R)
+* inv(B)*A = Z**H * (inv(T)*R)
*
-* where inv(B) denotes the inverse of the matrix B, and Z' denotes the
+* where inv(B) denotes the inverse of the matrix B, and Z**H denotes the
* conjugate transpose of matrix Z.
*
* Arguments
*
* Each H(i) has the form
*
-* H(i) = I - taua * v * v'
+* H(i) = I - taua * v * v**H
*
* where taua is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i+1:n,i),
*
* Each H(i) has the form
*
-* H(i) = I - taub * v * v'
+* H(i) = I - taub * v * v**H
*
* where taub is a complex scalar, and v is a complex vector with
* v(p-k+i+1:p) = 0 and v(p-k+i) = 1; v(1:p-k+i-1) is stored on exit in
CALL ZGEQRF( N, M, A, LDA, TAUA, WORK, LWORK, INFO )
LOPT = WORK( 1 )
*
-* Update B := Q'*B.
+* Update B := Q**H*B.
*
CALL ZUNMQR( 'Left', 'Conjugate Transpose', N, P, MIN( N, M ), A,
$ LDA, TAUA, B, LDB, WORK, LWORK, INFO )
* In particular, if B is square and nonsingular, the GRQ factorization
* of A and B implicitly gives the RQ factorization of A*inv(B):
*
-* A*inv(B) = (R*inv(T))*Z'
+* A*inv(B) = (R*inv(T))*Z**H
*
-* where inv(B) denotes the inverse of the matrix B, and Z' denotes the
+* where inv(B) denotes the inverse of the matrix B, and Z**H denotes the
* conjugate transpose of the matrix Z.
*
* Arguments
*
* Each H(i) has the form
*
-* H(i) = I - taua * v * v'
+* H(i) = I - taua * v * v**H
*
* where taua is a complex scalar, and v is a complex vector with
* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - taub * v * v'
+* H(i) = I - taub * v * v**H
*
* where taub is a complex scalar, and v is a complex vector with
* v(1:i-1) = 0 and v(i) = 1; v(i+1:p) is stored on exit in B(i+1:p,i),
CALL ZGERQF( M, N, A, LDA, TAUA, WORK, LWORK, INFO )
LOPT = WORK( 1 )
*
-* Update B := B*Q'
+* Update B := B*Q**H
*
CALL ZUNMRQ( 'Right', 'Conjugate Transpose', P, N, MIN( M, N ),
$ A( MAX( 1, M-N+1 ), 1 ), LDA, TAUA, B, LDB, WORK,
* ZGGSVD computes the generalized singular value decomposition (GSVD)
* of an M-by-N complex matrix A and P-by-N complex matrix B:
*
-* U'*A*Q = D1*( 0 R ), V'*B*Q = D2*( 0 R )
+* U**H*A*Q = D1*( 0 R ), V**H*B*Q = D2*( 0 R )
*
-* where U, V and Q are unitary matrices, and Z' means the conjugate
-* transpose of Z. Let K+L = the effective numerical rank of the
-* matrix (A',B')', then R is a (K+L)-by-(K+L) nonsingular upper
+* where U, V and Q are unitary matrices.
+* Let K+L = the effective numerical rank of the
+* matrix (A**H,B**H)**H, then R is a (K+L)-by-(K+L) nonsingular upper
* triangular matrix, D1 and D2 are M-by-(K+L) and P-by-(K+L) "diagonal"
* matrices and of the following structures, respectively:
*
*
* In particular, if B is an N-by-N nonsingular matrix, then the GSVD of
* A and B implicitly gives the SVD of A*inv(B):
-* A*inv(B) = U*(D1*inv(D2))*V'.
-* If ( A',B')' has orthnormal columns, then the GSVD of A and B is also
+* A*inv(B) = U*(D1*inv(D2))*V**H.
+* If ( A**H,B**H)**H has orthnormal columns, then the GSVD of A and B is also
* equal to the CS decomposition of A and B. Furthermore, the GSVD can
* be used to derive the solution of the eigenvalue problem:
-* A'*A x = lambda* B'*B x.
+* A**H*A x = lambda* B**H*B x.
* In some literature, the GSVD of A and B is presented in the form
-* U'*A*X = ( 0 D1 ), V'*B*X = ( 0 D2 )
+* U**H*A*X = ( 0 D1 ), V**H*B*X = ( 0 D2 )
* where U and V are orthogonal and X is nonsingular, and D1 and D2 are
* ``diagonal''. The former GSVD form can be converted to the latter
* form by taking the nonsingular matrix X as
* L (output) INTEGER
* On exit, K and L specify the dimension of the subblocks
* described in Purpose.
-* K + L = effective numerical rank of (A',B')'.
+* K + L = effective numerical rank of (A**H,B**H)**H.
*
* A (input/output) COMPLEX*16 array, dimension (LDA,N)
* On entry, the M-by-N matrix A.
* TOLA DOUBLE PRECISION
* TOLB DOUBLE PRECISION
* TOLA and TOLB are the thresholds to determine the effective
-* rank of (A',B')'. Generally, they are set to
+* rank of (A**H,B**H)**H. Generally, they are set to
* TOLA = MAX(M,N)*norm(A)*MAZHEPS,
* TOLB = MAX(P,N)*norm(B)*MAZHEPS.
* The size of TOLA and TOLB may affect the size of backward
*
* ZGGSVP computes unitary matrices U, V and Q such that
*
-* N-K-L K L
-* U'*A*Q = K ( 0 A12 A13 ) if M-K-L >= 0;
-* L ( 0 0 A23 )
-* M-K-L ( 0 0 0 )
+* N-K-L K L
+* U**H*A*Q = K ( 0 A12 A13 ) if M-K-L >= 0;
+* L ( 0 0 A23 )
+* M-K-L ( 0 0 0 )
*
* N-K-L K L
* = K ( 0 A12 A13 ) if M-K-L < 0;
* M-K ( 0 0 A23 )
*
-* N-K-L K L
-* V'*B*Q = L ( 0 0 B13 )
-* P-L ( 0 0 0 )
+* N-K-L K L
+* V**H*B*Q = L ( 0 0 B13 )
+* P-L ( 0 0 0 )
*
* where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular
* upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,
* otherwise A23 is (M-K)-by-L upper trapezoidal. K+L = the effective
-* numerical rank of the (M+P)-by-N matrix (A',B')'. Z' denotes the
-* conjugate transpose of Z.
+* numerical rank of the (M+P)-by-N matrix (A**H,B**H)**H.
*
* This decomposition is the preprocessing step for computing the
* Generalized Singular Value Decomposition (GSVD), see subroutine
* L (output) INTEGER
* On exit, K and L specify the dimension of the subblocks
* described in Purpose section.
-* K + L = effective numerical rank of (A',B')'.
+* K + L = effective numerical rank of (A**H,B**H)**H.
*
* U (output) COMPLEX*16 array, dimension (LDU,M)
* If JOBU = 'U', U contains the unitary matrix U.
*
CALL ZGERQ2( L, N, B, LDB, TAU, WORK, INFO )
*
-* Update A := A*Z'
+* Update A := A*Z**H
*
CALL ZUNMR2( 'Right', 'Conjugate transpose', M, N, L, B, LDB,
$ TAU, A, LDA, WORK, INFO )
IF( WANTQ ) THEN
*
-* Update Q := Q*Z'
+* Update Q := Q*Z**H
*
CALL ZUNMR2( 'Right', 'Conjugate transpose', N, N, L, B,
$ LDB, TAU, Q, LDQ, WORK, INFO )
*
* then the following does the complete QR decomposition of A11:
*
-* A11 = U*( 0 T12 )*P1'
+* A11 = U*( 0 T12 )*P1**H
* ( 0 0 )
*
DO 70 I = 1, N - L
$ K = K + 1
80 CONTINUE
*
-* Update A12 := U'*A12, where A12 = A( 1:M, N-L+1:N )
+* Update A12 := U**H*A12, where A12 = A( 1:M, N-L+1:N )
*
CALL ZUNM2R( 'Left', 'Conjugate transpose', M, L, MIN( M, N-L ),
$ A, LDA, TAU, A( 1, N-L+1 ), LDA, WORK, INFO )
*
IF( WANTQ ) THEN
*
-* Update Q( 1:N,1:N-L ) = Q( 1:N,1:N-L )*Z1'
+* Update Q( 1:N,1:N-L ) = Q( 1:N,1:N-L )*Z1**H
*
CALL ZUNMR2( 'Right', 'Conjugate transpose', N, N-L, K, A,
$ LDA, TAU, Q, LDQ, WORK, INFO )
$ WORK, N, INFO )
ELSE
*
-* Multiply by inv(L')*inv(U').
+* Multiply by inv(L**H)*inv(U**H).
*
CALL ZGTTRS( 'Conjugate transpose', N, 1, DL, D, DU, DU2,
$ IPIV, WORK, N, INFO )
* where A is an N-by-N tridiagonal matrix, by Gaussian elimination with
* partial pivoting.
*
-* Note that the equation A'*X = B may be solved by interchanging the
+* Note that the equation A**H *X = B may be solved by interchanging the
* order of the arguments DU and DL.
*
* Arguments
CALL ZLACN2( N, WORK( N+1 ), WORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**H) or inv(U*D*U**H).
*
CALL ZHETRS( UPLO, N, 1, A, LDA, IPIV, WORK, N, INFO )
GO TO 30
* eigenproblem to standard form.
*
* If ITYPE = 1, the problem is A*x = lambda*B*x,
-* and A is overwritten by inv(U')*A*inv(U) or inv(L)*A*inv(L')
+* and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)
*
* If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or
-* B*A*x = lambda*x, and A is overwritten by U*A*U` or L'*A*L.
+* B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H *A*L.
*
-* B must have been previously factorized as U'*U or L*L' by ZPOTRF.
+* B must have been previously factorized as U**H *U or L*L**H by ZPOTRF.
*
* Arguments
* =========
*
* ITYPE (input) INTEGER
-* = 1: compute inv(U')*A*inv(U) or inv(L)*A*inv(L');
-* = 2 or 3: compute U*A*U' or L'*A*L.
+* = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H);
+* = 2 or 3: compute U*A*U**H or L**H *A*L.
*
* UPLO (input) CHARACTER*1
* Specifies whether the upper or lower triangular part of the
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**H)*A*inv(U)
*
DO 10 K = 1, N
*
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**H)
*
DO 20 K = 1, N
*
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**H
*
DO 30 K = 1, N
*
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**H *A*L
*
DO 40 K = 1, N
*
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**H)*A*inv(U)
*
DO 10 K = 1, N, NB
KB = MIN( N-K+1, NB )
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**H)
*
DO 20 K = 1, N, NB
KB = MIN( N-K+1, NB )
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**H
*
DO 30 K = 1, N, NB
KB = MIN( N-K+1, NB )
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**H*A*L
*
DO 40 K = 1, N, NB
KB = MIN( N-K+1, NB )
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H *y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H *y
*
IF( UPPER ) THEN
TRANS = 'C'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H *y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H *y
*
IF( UPPER ) THEN
TRANS = 'C'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H *y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H *y
*
IF( UPPER ) THEN
TRANS = 'C'
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**H or A = L*D*L**H.
*
CALL ZHETRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**H or A = L*D*L**H.
*
CALL ZLACPY( UPLO, N, N, A, LDA, AF, LDAF )
CALL ZHETRF( UPLO, N, AF, LDAF, IPIV, WORK, LWORK, INFO )
*
* ZHETD2 reduces a complex Hermitian matrix A to real symmetric
* tridiagonal form T by a unitary similarity transformation:
-* Q' * A * Q = T.
+* Q**H * A * Q = T.
*
* Arguments
* =========
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i),
* Test the input parameters
*
INFO = 0
- UPPER = LSAME( UPLO, 'U' )
+ UPPER = LSAME( UPLO, 'U')
IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
INFO = -1
ELSE IF( N.LT.0 ) THEN
A( N, N ) = DBLE( A( N, N ) )
DO 10 I = N - 1, 1, -1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**H
* to annihilate A(1:i-1,i+1)
*
ALPHA = A( I, I+1 )
CALL ZHEMV( UPLO, I, TAUI, A, LDA, A( 1, I+1 ), 1, ZERO,
$ TAU, 1 )
*
-* Compute w := x - 1/2 * tau * (x'*v) * v
+* Compute w := x - 1/2 * tau * (x**H * v) * v
*
ALPHA = -HALF*TAUI*ZDOTC( I, TAU, 1, A( 1, I+1 ), 1 )
CALL ZAXPY( I, ALPHA, A( 1, I+1 ), 1, TAU, 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v'
+* A := A - v * w**H - w * v**H
*
CALL ZHER2( UPLO, I, -ONE, A( 1, I+1 ), 1, TAU, 1, A,
$ LDA )
A( 1, 1 ) = DBLE( A( 1, 1 ) )
DO 20 I = 1, N - 1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**H
* to annihilate A(i+2:n,i)
*
ALPHA = A( I+1, I )
CALL ZHEMV( UPLO, N-I, TAUI, A( I+1, I+1 ), LDA,
$ A( I+1, I ), 1, ZERO, TAU( I ), 1 )
*
-* Compute w := x - 1/2 * tau * (x'*v) * v
+* Compute w := x - 1/2 * tau * (x**H * v) * v
*
ALPHA = -HALF*TAUI*ZDOTC( N-I, TAU( I ), 1, A( I+1, I ),
$ 1 )
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'
+* A := A - v * w' - w * v**H
*
CALL ZHER2( UPLO, N-I, -ONE, A( I+1, I ), 1, TAU( I ), 1,
$ A( I+1, I+1 ), LDA )
* ZHETF2 computes the factorization of a complex Hermitian matrix A
* using the Bunch-Kaufman diagonal pivoting method:
*
-* A = U*D*U' or A = L*D*L'
+* A = U*D*U**H or A = L*D*L**H
*
* where U (or L) is a product of permutation and unit upper (lower)
-* triangular matrices, U' is the conjugate transpose of U, and D is
+* triangular matrices, U**H is the conjugate transpose of U, and D is
* Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* J. Lewis, Boeing Computer Services Company
* A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**H, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**H, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**H using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**H = A - W(k)*1/D(k)*W(k)**H
*
R1 = ONE / DBLE( A( K, K ) )
CALL ZHER( UPLO, K-1, -R1, A( 1, K ), 1, A, LDA )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**H
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**H
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**H using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**H = A - W(k)*(1/D(k))*W(k)**H
*
R1 = ONE / DBLE( A( K, K ) )
CALL ZHER( UPLO, N-K, -R1, A( K+1, K ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )'
-* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )'
+* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )**H
+* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )**H
*
* where L(k) and L(k+1) are the k-th and (k+1)-th
* columns of L
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i),
$ LDWORK )
*
* Update the unreduced submatrix A(1:i-1,1:i-1), using an
-* update of the form: A := A - V*W' - W*V'
+* update of the form: A := A - V*W' - 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'
+* an update of the form: A := A - V*W' - W*V**H
*
CALL ZHER2K( UPLO, 'No transpose', N-I-NB+1, NB, -CONE,
$ A( I+NB, I ), LDA, WORK( NB+1 ), LDWORK, ONE,
* Further Details
* ===============
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**H, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**H, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**H using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* KB, where KB is the number of columns factorized by ZLAHEF;
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**H using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* KB, where KB is the number of columns factorized by ZLAHEF;
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**H.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**H.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
IF( UPPER ) THEN
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**H)*inv(D)*inv(U)*P'.
*
CALL ZTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**H) = (inv(U))**H
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**H)*inv(D)*inv(U)
*
CUT=N
DO WHILE (CUT .GT. 0)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**H)*inv(D)*inv(U) *P'
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**H)*inv(D)*inv(U)*P'.
*
CALL ZTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**H) = (inv(U))**H
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**H)*inv(D)*inv(U)
*
CUT=0
DO WHILE (CUT .LT. N)
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**H)*inv(D)*inv(U) *P'
*
I=N
DO WHILE ( I .GE. 1 )
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**H.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**H *X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**H(K)), where U(K) is the transformation
* stored in column K of A.
*
IF( K.GT.1 ) THEN
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**H(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
IF( K.GT.1 ) THEN
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**H.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**H *X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**H(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N ) THEN
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**H(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
* Purpose
* =======
*
-* ZHETRS2 solves a system of linear equations A*X = B with a real
-* Hermitian matrix A using the factorization A = U*D*U**T or
-* A = L*D*L**T computed by ZSYTRF and converted by ZSYCONV.
+* ZHETRS2 solves a system of linear equations A*X = B with a complex
+* Hermitian matrix A using the factorization A = U*D*U**H or
+* A = L*D*L**H computed by ZHETRF and converted by ZSYCONV.
*
* Arguments
* =========
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**H.
*
-* P' * B
+* P**T * B
K=N
DO WHILE ( K .GE. 1 )
IF( IPIV( K ).GT.0 ) THEN
END IF
END DO
*
-* Compute (U \P' * B) -> B [ (U \P' * B) ]
+* Compute (U \P**T * B) -> B [ (U \P**T * B) ]
*
CALL ZTRSM('L','U','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (U \P' * B) ]
+* Compute D \ B -> B [ D \ (U \P**T * B) ]
*
I=N
DO WHILE ( I .GE. 1 )
I = I - 1
END DO
*
-* Compute (U' \ B) -> B [ U' \ (D \ (U \P' * B) ) ]
+* Compute (U**H \ B) -> B [ U**H \ (D \ (U \P**T * B) ) ]
*
CALL ZTRSM('L','U','C','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (U' \ (D \ (U \P' * B) )) ]
+* P * B [ P * (U**H \ (D \ (U \P**T * B) )) ]
*
K=1
DO WHILE ( K .LE. N )
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**H.
*
-* P' * B
+* P**T * B
K=1
DO WHILE ( K .LE. N )
IF( IPIV( K ).GT.0 ) THEN
ENDIF
END DO
*
-* Compute (L \P' * B) -> B [ (L \P' * B) ]
+* Compute (L \P**T * B) -> B [ (L \P**T * B) ]
*
CALL ZTRSM('L','L','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (L \P' * B) ]
+* Compute D \ B -> B [ D \ (L \P**T * B) ]
*
I=1
DO WHILE ( I .LE. N )
I = I + 1
END DO
*
-* Compute (L' \ B) -> B [ L' \ (D \ (L \P' * B) ) ]
+* Compute (L**H \ B) -> B [ L**H \ (D \ (L \P**T * B) ) ]
*
CALL ZTRSM('L','L','C','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (L' \ (D \ (L \P' * B) )) ]
+* P * B [ P * (L**H \ (D \ (L \P**T * B) )) ]
*
K=N
DO WHILE ( K .GE. 1 )
CALL ZLACN2( N, WORK( N+1 ), WORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**H) or inv(U*D*U**H).
*
CALL ZHPTRS( UPLO, N, 1, AP, IPIV, WORK, N, INFO )
GO TO 30
IF( ITYPE.EQ.1 ) THEN
IF( UPPER ) THEN
*
-* Compute inv(U')*A*inv(U)
+* Compute inv(U**H)*A*inv(U)
*
* J1 and JJ are the indices of A(1,j) and A(j,j)
*
10 CONTINUE
ELSE
*
-* Compute inv(L)*A*inv(L')
+* Compute inv(L)*A*inv(L**H)
*
* KK and K1K1 are the indices of A(k,k) and A(k+1,k+1)
*
ELSE
IF( UPPER ) THEN
*
-* Compute U*A*U'
+* Compute U*A*U**H
*
* K1 and KK are the indices of A(1,k) and A(k,k)
*
30 CONTINUE
ELSE
*
-* Compute L'*A*L
+* Compute L**H *A*L
*
* JJ and J1J1 are the indices of A(j,j) and A(j+1,j+1)
*
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H *y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H *y
*
IF( UPPER ) THEN
TRANS = 'C'
* On exit, if INFO = 0, WORK(1) returns the required LWORK.
*
* LWORK (input) INTEGER
-* The dimension of array WORK.
+* The dimension of the array WORK.
* If N <= 1, LWORK >= 1.
* If JOBZ = 'N' and N > 1, LWORK >= N.
* If JOBZ = 'V' and N > 1, LWORK >= 2*N.
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H *y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H *y
*
IF( UPPER ) THEN
TRANS = 'C'
IF( ITYPE.EQ.1 .OR. ITYPE.EQ.2 ) THEN
*
* For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
-* backtransform eigenvectors: x = inv(L)'*y or inv(U)*y
+* backtransform eigenvectors: x = inv(L)**H *y or inv(U)*y
*
IF( UPPER ) THEN
TRANS = 'N'
ELSE IF( ITYPE.EQ.3 ) THEN
*
* For B*A*x=(lambda)*x;
-* backtransform eigenvectors: x = L*y or U'*y
+* backtransform eigenvectors: x = L*y or U**H *y
*
IF( UPPER ) THEN
TRANS = 'C'
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**H or A = L*D*L**H.
*
CALL ZHPTRF( UPLO, N, AP, IPIV, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**H or A = L*D*L**H.
*
CALL ZCOPY( N*( N+1 ) / 2, AP, 1, AFP, 1 )
CALL ZHPTRF( UPLO, N, AFP, IPIV, INFO )
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in AP,
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in AP,
AP( I1+N-1 ) = DBLE( AP( I1+N-1 ) )
DO 10 I = N - 1, 1, -1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**H
* to annihilate A(1:i-1,i+1)
*
ALPHA = AP( I1+I-1 )
CALL ZHPMV( UPLO, I, TAUI, AP, AP( I1 ), 1, ZERO, TAU,
$ 1 )
*
-* Compute w := y - 1/2 * tau * (y'*v) * v
+* Compute w := y - 1/2 * tau * (y**H *v) * v
*
ALPHA = -HALF*TAUI*ZDOTC( I, TAU, 1, AP( I1 ), 1 )
CALL ZAXPY( I, ALPHA, AP( I1 ), 1, TAU, 1 )
*
* Apply the transformation as a rank-2 update:
-* A := A - v * w' - w * v'
+* A := A - v * w**H - w * v**H
*
CALL ZHPR2( UPLO, I, -ONE, AP( I1 ), 1, TAU, 1, AP )
*
DO 20 I = 1, N - 1
I1I1 = II + N - I + 1
*
-* Generate elementary reflector H(i) = I - tau * v * v'
+* Generate elementary reflector H(i) = I - tau * v * v**H
* to annihilate A(i+2:n,i)
*
ALPHA = AP( II+1 )
CALL ZHPMV( UPLO, N-I, TAUI, AP( I1I1 ), AP( II+1 ), 1,
$ ZERO, TAU( I ), 1 )
*
-* Compute w := y - 1/2 * tau * (y'*v) * v
+* Compute w := y - 1/2 * tau * (y**H *v) * v
*
ALPHA = -HALF*TAUI*ZDOTC( N-I, TAU( I ), 1, AP( II+1 ),
$ 1 )
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'
+* A := A - v * w' - w * v**H
*
CALL ZHPR2( UPLO, N-I, -ONE, AP( II+1 ), 1, TAU( I ), 1,
$ AP( I1I1 ) )
* 5-96 - Based on modifications by J. Lewis, Boeing Computer Services
* Company
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**H, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**H, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**H using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**H = A - W(k)*1/D(k)*W(k)**H
*
R1 = ONE / DBLE( AP( KC+K-1 ) )
CALL ZHPR( UPLO, K-1, -R1, AP( KC ), 1, AP )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**H
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**H
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**H using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**H = A - W(k)*(1/D(k))*W(k)**H
*
R1 = ONE / DBLE( AP( KC ) )
CALL ZHPR( UPLO, N-K, -R1, AP( KC+1 ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )'
-* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )'
+* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )**H
+* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )**H
*
* where L(k) and L(k+1) are the k-th and (k+1)-th
* columns of L
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**H.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**H.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**H.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**H *X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**H(K)), where U(K) is the transformation
* stored in column K of A.
*
IF( K.GT.1 ) THEN
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**H(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
IF( K.GT.1 ) THEN
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**H.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**H *X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**H(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N ) THEN
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**H(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
* Purpose
* =======
*
-* DLA_GBAMV performs one of the matrix-vector operations
+* ZLA_GBAMV performs one of the matrix-vector operations
*
* y := alpha*abs(A)*abs(x) + beta*abs(y),
-* or y := alpha*abs(A)'*abs(x) + beta*abs(y),
+* or y := alpha*abs(A)**T*abs(x) + beta*abs(y),
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
* follows:
*
* BLAS_NO_TRANS y := alpha*abs(A)*abs(x) + beta*abs(y)
-* BLAS_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
-* BLAS_CONJ_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
+* BLAS_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
+* BLAS_CONJ_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
*
* Unchanged on exit.
*
-* M (input) INTEGER
+* M (input) INTEGER
* On entry, M specifies the number of rows of the matrix A.
* M must be at least zero.
* Unchanged on exit.
*
-* N (input) INTEGER
+* N (input) INTEGER
* On entry, N specifies the number of columns of the matrix A.
* N must be at least zero.
* Unchanged on exit.
*
-* KL (input) INTEGER
+* KL (input) INTEGER
* The number of subdiagonals within the band of A. KL >= 0.
*
-* KU (input) INTEGER
+* KU (input) INTEGER
* The number of superdiagonals within the band of A. KU >= 0.
*
-* ALPHA - DOUBLE PRECISION
+* ALPHA (input) DOUBLE PRECISION
* On entry, ALPHA specifies the scalar alpha.
* Unchanged on exit.
*
-* A - DOUBLE PRECISION array of DIMENSION ( LDA, n )
-* Before entry, the leading m by n part of the array A must
+* AB (input) COMPLEX*16 array of DIMENSION ( LDAB, n )
+* Before entry, the leading m by n part of the array AB must
* contain the matrix of coefficients.
* Unchanged on exit.
*
-* LDA (input) INTEGER
-* On entry, LDA specifies the first dimension of A as declared
-* in the calling (sub) program. LDA must be at least
+* LDAB (input) INTEGER
+* On entry, LDAB specifies the first dimension of AB as declared
+* in the calling (sub) program. LDAB must be at least
* max( 1, m ).
* Unchanged on exit.
*
-* X (input) DOUBLE PRECISION array, dimension
+* X (input) COMPLEX*16 array, dimension
* ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
* vector x.
* Unchanged on exit.
*
-* INCX (input) INTEGER
+* INCX (input) INTEGER
* On entry, INCX specifies the increment for the elements of
* X. INCX must not be zero.
* Unchanged on exit.
*
-* BETA - DOUBLE PRECISION
+* BETA (input) DOUBLE PRECISION
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input.
* Unchanged on exit.
*
-* Y (input/output) DOUBLE PRECISION array, dimension
+* Y (input/output) DOUBLE PRECISION array, dimension
* ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
* must contain the vector y. On exit, Y is overwritten by the
* updated vector y.
*
-* INCY (input) INTEGER
+* INCY (input) INTEGER
* On entry, INCY specifies the increment for the elements of
* Y. INCY must not be zero.
* Unchanged on exit.
* ZLA_GEAMV performs one of the matrix-vector operations
*
* y := alpha*abs(A)*abs(x) + beta*abs(y),
-* or y := alpha*abs(A)'*abs(x) + beta*abs(y),
+* or y := alpha*abs(A)**T*abs(x) + beta*abs(y),
*
* where alpha and beta are scalars, x and y are vectors and A is an
* m by n matrix.
* Arguments
* ==========
*
-* TRANS (input) INTEGER
+* TRANS (input) INTEGER
* On entry, TRANS specifies the operation to be performed as
* follows:
*
* BLAS_NO_TRANS y := alpha*abs(A)*abs(x) + beta*abs(y)
-* BLAS_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
-* BLAS_CONJ_TRANS y := alpha*abs(A')*abs(x) + beta*abs(y)
+* BLAS_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
+* BLAS_CONJ_TRANS y := alpha*abs(A**T)*abs(x) + beta*abs(y)
*
* Unchanged on exit.
*
-* M (input) INTEGER
+* M (input) INTEGER
* On entry, M specifies the number of rows of the matrix A.
* M must be at least zero.
* Unchanged on exit.
*
-* N (input) INTEGER
+* N (input) INTEGER
* On entry, N specifies the number of columns of the matrix A.
* N must be at least zero.
* Unchanged on exit.
*
-* ALPHA - DOUBLE PRECISION
+* ALPHA (input) DOUBLE PRECISION
* On entry, ALPHA specifies the scalar alpha.
* Unchanged on exit.
*
-* A - COMPLEX*16 array of DIMENSION ( LDA, n )
+* A (input) COMPLEX*16 array of DIMENSION ( LDA, n )
* Before entry, the leading m by n part of the array A must
* contain the matrix of coefficients.
* Unchanged on exit.
*
-* LDA (input) INTEGER
+* LDA (input) INTEGER
* On entry, LDA specifies the first dimension of A as declared
* in the calling (sub) program. LDA must be at least
* max( 1, m ).
* Unchanged on exit.
*
-* X - COMPLEX*16 array of DIMENSION at least
+* X (input) COMPLEX*16 array of DIMENSION at least
* ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
* vector x.
* Unchanged on exit.
*
-* INCX (input) INTEGER
+* INCX (input) INTEGER
* On entry, INCX specifies the increment for the elements of
* X. INCX must not be zero.
* Unchanged on exit.
*
-* BETA - DOUBLE PRECISION
+* BETA (input) DOUBLE PRECISION
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input.
* Unchanged on exit.
*
-* Y (input/output) DOUBLE PRECISION array, dimension
+* Y (input/output) DOUBLE PRECISION array, dimension
* ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
* and at least
* ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
* must contain the vector y. On exit, Y is overwritten by the
* updated vector y.
*
-* INCY (input) INTEGER
+* INCY (input) INTEGER
* On entry, INCY specifies the increment for the elements of
* Y. INCY must not be zero.
* Unchanged on exit.
*
* ZLABRD reduces the first NB rows and columns of a complex general
* m by n matrix A to upper or lower real bidiagonal form by a unitary
-* transformation Q' * A * P, and returns the matrices X and Y which
+* transformation Q**H * A * P, and returns the matrices X and Y which
* are needed to apply the transformation to the unreduced part of A.
*
* If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower
*
* Each H(i) and G(i) has the form:
*
-* H(i) = I - tauq * v * v' and G(i) = I - taup * u * u'
+* H(i) = I - tauq * v * v**H and G(i) = I - taup * u * u**H
*
* where tauq and taup are complex scalars, and v and u are complex
* vectors.
* A(i,i+1:n); tauq is stored in TAUQ(i) and taup in TAUP(i).
*
* The elements of the vectors v and u together form the m-by-nb matrix
-* V and the nb-by-n matrix U' which are needed, with X and Y, to apply
+* V and the nb-by-n matrix U**H which are needed, with X and Y, to apply
* the transformation to the unreduced part of the matrix, using a block
-* update of the form: A := A - V*Y' - X*U'.
+* update of the form: A := A - V*Y**H - X*U**H.
*
* The contents of A on exit are illustrated by the following examples
* with nb = 2:
* eigenvalues and optionally eigenvectors of a dense or banded
* Hermitian matrix that has been reduced to tridiagonal form.
*
-* T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)
+* T = Q(in) ( D(in) + RHO * Z*Z**H ) Q**H(in) = Q(out) * D(out) * Q**H(out)
*
-* where Z = Q'u, u is a vector of length N with ones in the
+* where Z = Q**Hu, u is a vector of length N with ones in the
* CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.
*
* The eigenvectors of the original matrix are stored in Q, and the
DO 110 ITS = 1, N
*
* Solve U*x = scale*v for a right eigenvector
-* or U'*x = scale*v for a left eigenvector,
+* or U**H *x = scale*v for a left eigenvector,
* overwriting x on v.
*
CALL ZLATRS( 'Upper', TRANS, 'Nonunit', NORMIN, N, B, LDB, V,
* ZLAGS2 computes 2-by-2 unitary matrices U, V and Q, such
* that if ( UPPER ) then
*
-* U'*A*Q = U'*( A1 A2 )*Q = ( x 0 )
-* ( 0 A3 ) ( x x )
+* U**H *A*Q = U**H *( A1 A2 )*Q = ( x 0 )
+* ( 0 A3 ) ( x x )
* and
-* V'*B*Q = V'*( B1 B2 )*Q = ( x 0 )
-* ( 0 B3 ) ( x x )
+* V**H*B*Q = V**H *( B1 B2 )*Q = ( x 0 )
+* ( 0 B3 ) ( x x )
*
* or if ( .NOT.UPPER ) then
*
-* U'*A*Q = U'*( A1 0 )*Q = ( x x )
-* ( A2 A3 ) ( 0 x )
+* U**H *A*Q = U**H *( A1 0 )*Q = ( x x )
+* ( A2 A3 ) ( 0 x )
* and
-* V'*B*Q = V'*( B1 0 )*Q = ( x x )
-* ( B2 B3 ) ( 0 x )
+* V**H *B*Q = V**H *( B1 0 )*Q = ( x x )
+* ( B2 B3 ) ( 0 x )
* where
*
-* U = ( CSU SNU ), V = ( CSV SNV ),
-* ( -CONJG(SNU) CSU ) ( -CONJG(SNV) CSV )
+* U = ( CSU SNU ), V = ( CSV SNV ),
+* ( -SNU**H CSU ) ( -SNV**H CSV )
*
-* Q = ( CSQ SNQ )
-* ( -CONJG(SNQ) CSQ )
-*
-* Z' denotes the conjugate transpose of Z.
+* Q = ( CSQ SNQ )
+* ( -SNQ**H CSQ )
*
* The rows of the transformed A and B are parallel. Moreover, if the
* input 2-by-2 matrix A is not zero, then the transformed (1,1) entry
IF( ABS( CSL ).GE.ABS( SNL ) .OR. ABS( CSR ).GE.ABS( SNR ) )
$ THEN
*
-* Compute the (1,1) and (1,2) elements of U'*A and V'*B,
-* and (1,2) element of |U|'*|A| and |V|'*|B|.
+* Compute the (1,1) and (1,2) elements of U**H *A and V**H *B,
+* and (1,2) element of |U|**H *|A| and |V|**H *|B|.
*
UA11R = CSL*A1
UA12 = CSL*A2 + D1*SNL*A3
AUA12 = ABS( CSL )*ABS1( A2 ) + ABS( SNL )*ABS( A3 )
AVB12 = ABS( CSR )*ABS1( B2 ) + ABS( SNR )*ABS( B3 )
*
-* zero (1,2) elements of U'*A and V'*B
+* zero (1,2) elements of U**H *A and V**H *B
*
IF( ( ABS( UA11R )+ABS1( UA12 ) ).EQ.ZERO ) THEN
CALL ZLARTG( -DCMPLX( VB11R ), DCONJG( VB12 ), CSQ, SNQ,
*
ELSE
*
-* Compute the (2,1) and (2,2) elements of U'*A and V'*B,
-* and (2,2) element of |U|'*|A| and |V|'*|B|.
+* Compute the (2,1) and (2,2) elements of U**H *A and V**H *B,
+* and (2,2) element of |U|**H *|A| and |V|**H *|B|.
*
UA21 = -DCONJG( D1 )*SNL*A1
UA22 = -DCONJG( D1 )*SNL*A2 + CSL*A3
AUA22 = ABS( SNL )*ABS1( A2 ) + ABS( CSL )*ABS( A3 )
AVB22 = ABS( SNR )*ABS1( B2 ) + ABS( CSR )*ABS( B3 )
*
-* zero (2,2) elements of U'*A and V'*B, and then swap.
+* zero (2,2) elements of U**H *A and V**H *B, and then swap.
*
IF( ( ABS1( UA21 )+ABS1( UA22 ) ).EQ.ZERO ) THEN
CALL ZLARTG( -DCONJG( VB21 ), DCONJG( VB22 ), CSQ, SNQ,
IF( ABS( CSR ).GE.ABS( SNR ) .OR. ABS( CSL ).GE.ABS( SNL ) )
$ THEN
*
-* Compute the (2,1) and (2,2) elements of U'*A and V'*B,
-* and (2,1) element of |U|'*|A| and |V|'*|B|.
+* Compute the (2,1) and (2,2) elements of U**H *A and V**H *B,
+* and (2,1) element of |U|**H *|A| and |V|**H *|B|.
*
UA21 = -D1*SNR*A1 + CSR*A2
UA22R = CSR*A3
AUA21 = ABS( SNR )*ABS( A1 ) + ABS( CSR )*ABS1( A2 )
AVB21 = ABS( SNL )*ABS( B1 ) + ABS( CSL )*ABS1( B2 )
*
-* zero (2,1) elements of U'*A and V'*B.
+* zero (2,1) elements of U**H *A and V**H *B.
*
IF( ( ABS1( UA21 )+ABS( UA22R ) ).EQ.ZERO ) THEN
CALL ZLARTG( DCMPLX( VB22R ), VB21, CSQ, SNQ, R )
*
ELSE
*
-* Compute the (1,1) and (1,2) elements of U'*A and V'*B,
-* and (1,1) element of |U|'*|A| and |V|'*|B|.
+* Compute the (1,1) and (1,2) elements of U**H *A and V**H *B,
+* and (1,1) element of |U|**H *|A| and |V|**H *|B|.
*
UA11 = CSR*A1 + DCONJG( D1 )*SNR*A2
UA12 = DCONJG( D1 )*SNR*A3
AUA11 = ABS( CSR )*ABS( A1 ) + ABS( SNR )*ABS1( A2 )
AVB11 = ABS( CSL )*ABS( B1 ) + ABS( SNL )*ABS1( B2 )
*
-* zero (1,1) elements of U'*A and V'*B, and then swap.
+* zero (1,1) elements of U**H *A and V**H *B, and then swap.
*
IF( ( ABS1( UA11 )+ABS1( UA12 ) ).EQ.ZERO ) THEN
CALL ZLARTG( VB12, VB11, CSQ, SNQ, R )
120 CONTINUE
ELSE IF( LSAME( TRANS, 'T' ) ) THEN
*
-* Compute B := B - A'*X
+* Compute B := B - A**T *X
*
DO 140 J = 1, NRHS
IF( N.EQ.1 ) THEN
140 CONTINUE
ELSE IF( LSAME( TRANS, 'C' ) ) THEN
*
-* Compute B := B - A'*X
+* Compute B := B - A**H *X
*
DO 160 J = 1, NRHS
IF( N.EQ.1 ) THEN
* matrix A using the Bunch-Kaufman diagonal pivoting method. The
* partial factorization has the form:
*
-* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
-* ( 0 U22 ) ( 0 D ) ( U12' U22' )
+* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
+* ( 0 U22 ) ( 0 D ) ( U12**H U22**H )
*
-* A = ( L11 0 ) ( D 0 ) ( L11' L21' ) if UPLO = 'L'
-* ( L21 I ) ( 0 A22 ) ( 0 I )
+* A = ( L11 0 ) ( D 0 ) ( L11**H L21**H ) if UPLO = 'L'
+* ( L21 I ) ( 0 A22 ) ( 0 I )
*
* where the order of D is at most NB. The actual order is returned in
* the argument KB, and is either NB or NB-1, or N if N <= NB.
-* Note that U' denotes the conjugate transpose of U.
+* Note that U**H denotes the conjugate transpose of U.
*
* ZLAHEF is an auxiliary routine called by ZHETRF. It uses blocked code
* (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or
*
* Update the upper triangle of A11 (= A(1:k,1:k)) as
*
-* A11 := A11 - U12*D*U12' = A11 - U12*W'
+* A11 := A11 - U12*D*U12**H = A11 - U12*W**H
*
* computing blocks of NB columns at a time (note that conjg(W) is
* actually stored)
*
* Update the lower triangle of A22 (= A(k:n,k:n)) as
*
-* A22 := A22 - L21*D*L21' = A22 - L21*W'
+* A22 := A22 - L21*D*L21**H = A22 - L21*W**H
*
* computing blocks of NB columns at a time (note that conjg(W) is
* actually stored)
* ZLAHR2 reduces the first NB columns of A complex general n-BY-(n-k+1)
* matrix A so that elements below the k-th subdiagonal are zero. The
* reduction is performed by an unitary similarity transformation
-* Q' * A * Q. The routine returns the matrices V and T which determine
-* Q as a block reflector I - V*T*V', and also the matrix Y = A * V * T.
+* Q**H * A * Q. The routine returns the matrices V and T which determine
+* Q as a block reflector I - V*T*V**H, and also the matrix Y = A * V * T.
*
* This is an auxiliary routine called by ZGEHRD.
*
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit in
* The elements of the vectors v together form the (n-k+1)-by-nb matrix
* V which is needed, with T and Y, to apply the transformation to the
* unreduced part of the matrix, using an update of the form:
-* A := (I - V*T*V') * (A - Y*V').
+* A := (I - V*T*V**H) * (A - Y*V**H).
*
* The contents of A on exit are illustrated by the following example
* with n = 7, k = 3 and nb = 2:
*
* Update A(K+1:N,I)
*
-* Update I-th column of A - Y * V'
+* Update I-th column of A - Y * V**H
*
CALL ZLACGV( I-1, A( K+I-1, 1 ), LDA )
CALL ZGEMV( 'NO TRANSPOSE', N-K, I-1, -ONE, Y(K+1,1), LDY,
$ 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' to this column (call it b) from the
+* Apply I - V * T' * 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)
$ I-1, A( K+1, 1 ),
$ LDA, T( 1, NB ), 1 )
*
-* w := w + V2'*b2
+* w := w + V2**H * b2
*
CALL ZGEMV( 'Conjugate transpose', N-K-I+1, I-1,
$ ONE, A( K+I, 1 ),
$ LDA, A( K+I, I ), 1, ONE, T( 1, NB ), 1 )
*
-* w := T'*w
+* w := T**H * w
*
CALL ZTRMV( 'Upper', 'Conjugate transpose', 'NON-UNIT',
$ I-1, T, LDT,
* ZLAHRD reduces the first NB columns of a complex general n-by-(n-k+1)
* matrix A so that elements below the k-th subdiagonal are zero. The
* reduction is performed by a unitary similarity transformation
-* Q' * A * Q. The routine returns the matrices V and T which determine
-* Q as a block reflector I - V*T*V', and also the matrix Y = A * V * T.
+* Q**H * A * Q. The routine returns the matrices V and T which determine
+* Q as a block reflector I - V*T*V**H, and also the matrix Y = A * V * T.
*
* This is an OBSOLETE auxiliary routine.
* This routine will be 'deprecated' in a future release.
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit in
* The elements of the vectors v together form the (n-k+1)-by-nb matrix
* V which is needed, with T and Y, to apply the transformation to the
* unreduced part of the matrix, using an update of the form:
-* A := (I - V*T*V') * (A - Y*V').
+* A := (I - V*T*V**H) * (A - Y*V**H).
*
* The contents of A on exit are illustrated by the following example
* with n = 7, k = 3 and nb = 2:
*
* Update A(1:n,i)
*
-* Compute i-th column of A - Y * V'
+* Compute i-th column of A - Y * V**H
*
CALL ZLACGV( I-1, A( K+I-1, 1 ), LDA )
CALL ZGEMV( 'No transpose', N, I-1, -ONE, Y, LDY,
$ A( K+I-1, 1 ), LDA, ONE, A( 1, I ), 1 )
CALL ZLACGV( I-1, A( K+I-1, 1 ), LDA )
*
-* Apply I - V * T' * V' 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', I-1,
$ A( K+1, 1 ), LDA, T( 1, NB ), 1 )
*
-* w := w + V2'*b2
+* w := w + V2**H *b2
*
CALL ZGEMV( 'Conjugate transpose', N-K-I+1, I-1, ONE,
$ A( K+I, 1 ), LDA, A( K+I, I ), 1, ONE,
$ T( 1, NB ), 1 )
*
-* w := T'*w
+* w := T**H *w
*
CALL ZTRMV( 'Upper', 'Conjugate transpose', 'Non-unit', I-1,
$ T, LDT, T( 1, NB ), 1 )
* diag(sest*sest, 0) + [alpha gamma] * [ conjg(alpha) ]
* [ conjg(gamma) ]
*
-* where alpha = conjg(x)'*w.
+* where alpha = x**H * w.
*
* Arguments
* =========
END IF
*
* In the real version, B is passed to DLASDQ and multiplied
-* internally by Q'. Here B is complex and that product is
+* internally by Q**H. Here B is complex and that product is
* computed below in two steps (real and imaginary parts).
*
J = IRWB - 1
END IF
*
* In the real version, B is passed to DLASDQ and multiplied
-* internally by Q'. Here B is complex and that product is
+* internally by Q**H. Here B is complex and that product is
* computed below in two steps (real and imaginary parts).
*
J = IRWB - 1
* Purpose
* =======
*
-* ZLAQHB equilibrates a symmetric band matrix A using the scaling
-* factors in the vector S.
+* ZLAQHB equilibrates a Hermitian band matrix A
+* using the scaling factors in the vector S.
*
* Arguments
* =========
* if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
*
* On exit, if INFO = 0, the triangular factor U or L from the
-* Cholesky factorization A = U'*U or A = L*L' of the band
+* Cholesky factorization A = U**H *U or A = L*L**H of the band
* matrix A, in the same storage format as A.
*
* LDAB (input) INTEGER
*
IF( I.LT.N ) THEN
*
-* Apply H(i)' to A(offset+i:m,i+1:n) from the left.
+* Apply H(i)**H to A(offset+i:m,i+1:n) from the left.
*
AII = A( OFFPI, I )
A( OFFPI, I ) = CONE
* Auxiliar vector.
*
* F (input/output) COMPLEX*16 array, dimension (LDF,NB)
-* Matrix F' = L*Y'*A.
+* Matrix F**H = L * Y**H * A.
*
* LDF (input) INTEGER
* The leading dimension of the array F. LDF >= max(1,N).
* G. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain
* X. Sun, Computer Science Dept., Duke University, USA
*
+* Partial column norm updating strategy modified by
+* Z. Drmac and Z. Bujanovic, Dept. of Mathematics,
+* University of Zagreb, Croatia.
+* June 2010
+* For more details see LAPACK Working Note 176.
* =====================================================================
*
* .. Parameters ..
END IF
*
* Apply previous Householder reflectors to column K:
-* A(RK:M,K) := A(RK:M,K) - A(RK:M,1:K-1)*F(K,1:K-1)'.
+* A(RK:M,K) := A(RK:M,K) - A(RK:M,1:K-1)*F(K,1:K-1)**H.
*
IF( K.GT.1 ) THEN
DO 20 J = 1, K - 1
*
* Compute Kth column of F:
*
-* Compute F(K+1:N,K) := tau(K)*A(RK:M,K+1:N)'*A(RK:M,K).
+* Compute F(K+1:N,K) := tau(K)*A(RK:M,K+1:N)**H*A(RK:M,K).
*
IF( K.LT.N ) THEN
CALL ZGEMV( 'Conjugate transpose', M-RK+1, N-K, TAU( K ),
40 CONTINUE
*
* Incremental updating of F:
-* F(1:N,K) := F(1:N,K) - tau(K)*F(1:N,1:K-1)*A(RK:M,1:K-1)'
+* F(1:N,K) := F(1:N,K) - tau(K)*F(1:N,1:K-1)*A(RK:M,1:K-1)**H
* *A(RK:M,K).
*
IF( K.GT.1 ) THEN
END IF
*
* Update the current row of A:
-* A(RK,K+1:N) := A(RK,K+1:N) - A(RK,1:K)*F(K+1:N,1:K)'.
+* A(RK,K+1:N) := A(RK,K+1:N) - A(RK,1:K)*F(K+1:N,1:K)**H.
*
IF( K.LT.N ) THEN
CALL ZGEMM( 'No transpose', 'Conjugate transpose', 1, N-K,
*
* Apply the block reflector to the rest of the matrix:
* A(OFFSET+KB+1:M,KB+1:N) := A(OFFSET+KB+1:M,KB+1:N) -
-* A(OFFSET+KB+1:M,1:KB)*F(KB+1:N,1:KB)'.
+* A(OFFSET+KB+1:M,1:KB)*F(KB+1:N,1:KB)**H.
*
IF( KB.LT.MIN( N, M-OFFSET ) ) THEN
CALL ZGEMM( 'No transpose', 'Conjugate transpose', M-RK, N-KB,
* if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
*
* On exit, if INFO = 0, the triangular factor U or L from the
-* Cholesky factorization A = U'*U or A = L*L' of the band
+* Cholesky factorization A = U**T *U or A = L*L**T of the band
* matrix A, in the same storage format as A.
*
* LDAB (input) INTEGER
*
* ZLAR1V computes the (scaled) r-th column of the inverse of
* the sumbmatrix in rows B1 through BN of the tridiagonal matrix
-* L D L^T - sigma I. When sigma is close to an eigenvalue, the
+* L D L**T - sigma I. When sigma is close to an eigenvalue, the
* computed vector is an accurate eigenvector. Usually, r corresponds
* to the index where the eigenvector is largest in magnitude.
* The following steps accomplish this computation :
-* (a) Stationary qd transform, L D L^T - sigma I = L(+) D(+) L(+)^T,
-* (b) Progressive qd transform, L D L^T - sigma I = U(-) D(-) U(-)^T,
+* (a) Stationary qd transform, L D L**T - sigma I = L(+) D(+) L(+)**T,
+* (b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,
* (c) Computation of the diagonal elements of the inverse of
-* L D L^T - sigma I by combining the above transforms, and choosing
+* L D L**T - sigma I by combining the above transforms, and choosing
* r as the index where the diagonal of the inverse is (one of the)
* largest in magnitude.
* (d) Computation of the (scaled) r-th column of the inverse using the
* =========
*
* N (input) INTEGER
-* The order of the matrix L D L^T.
+* The order of the matrix L D L**T.
*
* B1 (input) INTEGER
-* First index of the submatrix of L D L^T.
+* First index of the submatrix of L D L**T.
*
* BN (input) INTEGER
-* Last index of the submatrix of L D L^T.
+* Last index of the submatrix of L D L**T.
*
* LAMBDA (input) DOUBLE PRECISION
* The shift. In order to compute an accurate eigenvector,
* LAMBDA should be a good approximation to an eigenvalue
-* of L D L^T.
+* of L D L**T.
*
* L (input) DOUBLE PRECISION array, dimension (N-1)
* The (n-1) subdiagonal elements of the unit bidiagonal matrix
*
* NEGCNT (output) INTEGER
* If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin
-* in the matrix factorization L D L^T, and NEGCNT = -1 otherwise.
+* in the matrix factorization L D L**T, and NEGCNT = -1 otherwise.
*
* ZTZ (output) DOUBLE PRECISION
* The square of the 2-norm of Z.
*
* MINGMA (output) DOUBLE PRECISION
* The reciprocal of the largest (in magnitude) diagonal
-* element of the inverse of L D L^T - sigma I.
+* element of the inverse of L D L**T - sigma I.
*
* R (input/output) INTEGER
* The twist index for the twisted factorization used to
* compute Z.
* On input, 0 <= R <= N. If R is input as 0, R is set to
-* the index where (L D L^T - sigma I)^{-1} is largest
+* the index where (L D L**T - sigma I)^{-1} is largest
* in magnitude. If 1 <= R <= N, R is unchanged.
* On output, R contains the twist index used to compute Z.
* Ideally, R designates the position of the maximum entry in the
* matrix C, from either the left or the right. H is represented in the
* form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**H
*
* where tau is a complex scalar and v is a complex vector.
*
* If tau = 0, then H is taken to be the unit matrix.
*
-* To apply H' (the conjugate transpose of H), supply conjg(tau) instead
+* To apply H**H, supply conjg(tau) instead
* tau.
*
* Arguments
*
IF( LASTV.GT.0 ) THEN
*
-* w(1:lastc,1) := C(1:lastv,1:lastc)' * v(1:lastv,1)
+* w(1:lastc,1) := C(1:lastv,1:lastc)**H * v(1:lastv,1)
*
CALL ZGEMV( 'Conjugate transpose', LASTV, LASTC, ONE,
$ C, LDC, V, INCV, ZERO, WORK, 1 )
*
-* C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)'
+* C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)**H
*
CALL ZGERC( LASTV, LASTC, -TAU, V, INCV, WORK, 1, C, LDC )
END IF
CALL ZGEMV( 'No transpose', LASTC, LASTV, ONE, C, LDC,
$ V, INCV, ZERO, WORK, 1 )
*
-* C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)'
+* C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)**H
*
CALL ZGERC( LASTC, LASTV, -TAU, WORK, 1, V, INCV, C, LDC )
END IF
* Purpose
* =======
*
-* ZLARFB applies a complex block reflector H or its transpose H' to a
+* ZLARFB applies a complex block reflector H or its transpose H**H to a
* complex M-by-N matrix C, from either the left or the right.
*
* Arguments
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply H or H' from the Left
-* = 'R': apply H or H' from the Right
+* = 'L': apply H or H**H from the Left
+* = 'R': apply H or H**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply H (No transpose)
-* = 'C': apply H' (Conjugate transpose)
+* = 'C': apply H**H (Conjugate transpose)
*
* DIRECT (input) CHARACTER*1
* Indicates how H is formed from a product of elementary
*
* C (input/output) COMPLEX*16 array, dimension (LDC,N)
* On entry, the M-by-N matrix C.
-* On exit, C is overwritten by H*C or H'*C or C*H or C*H'.
+* On exit, C is overwritten by H*C or H**H*C or C*H or C*H**H.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**H * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILAZLR( M, K, V, LDV ) )
LASTC = ILAZLC( LASTV, N, C, LDC )
*
-* W := C' * V = (C1'*V1 + C2'*V2) (stored in WORK)
+* W := C**H * V = (C1**H * V1 + C2**H * V2) (stored in WORK)
*
-* W := C1'
+* W := C1**H
*
DO 10 J = 1, K
CALL ZCOPY( LASTC, C( J, 1 ), LDC, WORK( 1, J ), 1 )
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2'*V2
+* W := W + C2**H *V2
*
CALL ZGEMM( 'Conjugate transpose', 'No transpose',
$ LASTC, K, LASTV-K, ONE, C( K+1, 1 ), LDC,
$ V( K+1, 1 ), LDV, ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**H or W * T
*
CALL ZTRMM( 'Right', 'Upper', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V * W'
+* C := C - V * W**H
*
IF( M.GT.K ) THEN
*
-* C2 := C2 - V2 * W'
+* C2 := C2 - V2 * W**H
*
CALL ZGEMM( 'No transpose', 'Conjugate transpose',
$ LASTV-K, LASTC, K,
$ ONE, C( K+1, 1 ), LDC )
END IF
*
-* W := W * V1'
+* W := W * V1**H
*
CALL ZTRMM( 'Right', 'Lower', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
-* C1 := C1 - W'
+* C1 := C1 - W**H
*
DO 30 J = 1, K
DO 20 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**H where C = ( C1 C2 )
*
LASTV = MAX( K, ILAZLR( N, K, V, LDV ) )
LASTC = ILAZLR( M, LASTV, C, LDC )
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**H
*
CALL ZTRMM( 'Right', 'Upper', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - W * V'
+* C := C - W * V**H
*
IF( LASTV.GT.K ) THEN
*
-* C2 := C2 - W * V2'
+* C2 := C2 - W * V2**H
*
CALL ZGEMM( 'No transpose', 'Conjugate transpose',
$ LASTC, LASTV-K, K,
$ ONE, C( 1, K+1 ), LDC )
END IF
*
-* W := W * V1'
+* W := W * V1**H
*
CALL ZTRMM( 'Right', 'Lower', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**H * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILAZLR( M, K, V, LDV ) )
LASTC = ILAZLC( LASTV, N, C, LDC )
*
-* W := C' * V = (C1'*V1 + C2'*V2) (stored in WORK)
+* W := C' * V = (C1**H * V1 + C2**H * V2) (stored in WORK)
*
-* W := C2'
+* W := C2**H
*
DO 70 J = 1, K
CALL ZCOPY( LASTC, C( LASTV-K+J, 1 ), LDC,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1'*V1
+* W := W + C1**H*V1
*
CALL ZGEMM( 'Conjugate transpose', 'No transpose',
$ LASTC, K, LASTV-K,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**H or W * T
*
CALL ZTRMM( 'Right', 'Lower', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V * W'
+* C := C - V * W**H
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - V1 * W'
+* C1 := C1 - V1 * W**H
*
CALL ZGEMM( 'No transpose', 'Conjugate transpose',
$ LASTV-K, LASTC, K,
$ ONE, C, LDC )
END IF
*
-* W := W * V2'
+* W := W * V2**H
*
CALL ZTRMM( 'Right', 'Upper', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V( LASTV-K+1, 1 ), LDV,
$ WORK, LDWORK )
*
-* C2 := C2 - W'
+* C2 := C2 - W**H
*
DO 90 J = 1, K
DO 80 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**H where C = ( C1 C2 )
*
LASTV = MAX( K, ILAZLR( N, K, V, LDV ) )
LASTC = ILAZLR( M, LASTV, C, LDC )
$ ONE, C, LDC, V, LDV, ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**H
*
CALL ZTRMM( 'Right', 'Lower', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - W * V'
+* C := C - W * V**H
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - W * V1'
+* C1 := C1 - W * V1**H
*
CALL ZGEMM( 'No transpose', 'Conjugate transpose',
$ LASTC, LASTV-K, K, -ONE, WORK, LDWORK, V, LDV,
$ ONE, C, LDC )
END IF
*
-* W := W * V2'
+* W := W * V2**H
*
CALL ZTRMM( 'Right', 'Upper', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V( LASTV-K+1, 1 ), LDV,
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**H * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILAZLC( K, M, V, LDV ) )
LASTC = ILAZLC( LASTV, N, C, LDC )
*
-* W := C' * V' = (C1'*V1' + C2'*V2') (stored in WORK)
+* W := C**H * V**H = (C1**H * V1**H + C2**H * V2**H) (stored in WORK)
*
-* W := C1'
+* W := C1**H
*
DO 130 J = 1, K
CALL ZCOPY( LASTC, C( J, 1 ), LDC, WORK( 1, J ), 1 )
CALL ZLACGV( LASTC, WORK( 1, J ), 1 )
130 CONTINUE
*
-* W := W * V1'
+* W := W * V1**H
*
CALL ZTRMM( 'Right', 'Upper', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2'*V2'
+* W := W + C2**H*V2**H
*
CALL ZGEMM( 'Conjugate transpose',
$ 'Conjugate transpose', LASTC, K, LASTV-K,
$ ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**H or W * T
*
CALL ZTRMM( 'Right', 'Upper', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V' * W'
+* C := C - V**H * W**H
*
IF( LASTV.GT.K ) THEN
*
-* C2 := C2 - V2' * W'
+* C2 := C2 - V2**H * W**H
*
CALL ZGEMM( 'Conjugate transpose',
$ 'Conjugate transpose', LASTV-K, LASTC, K,
CALL ZTRMM( 'Right', 'Upper', 'No transpose', 'Unit',
$ LASTC, K, ONE, V, LDV, WORK, LDWORK )
*
-* C1 := C1 - W'
+* C1 := C1 - W**H
*
DO 150 J = 1, K
DO 140 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**H where C = ( C1 C2 )
*
LASTV = MAX( K, ILAZLC( K, N, V, LDV ) )
LASTC = ILAZLR( M, LASTV, C, LDC )
*
-* W := C * V' = (C1*V1' + C2*V2') (stored in WORK)
+* W := C * V**H = (C1*V1**H + C2*V2**H) (stored in WORK)
*
* W := C1
*
CALL ZCOPY( LASTC, C( 1, J ), 1, WORK( 1, J ), 1 )
160 CONTINUE
*
-* W := W * V1'
+* W := W * V1**H
*
CALL ZTRMM( 'Right', 'Upper', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V, LDV, WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C2 * V2'
+* W := W + C2 * V2**H
*
CALL ZGEMM( 'No transpose', 'Conjugate transpose',
$ LASTC, K, LASTV-K, ONE, C( 1, K+1 ), LDC,
$ V( 1, K+1 ), LDV, ONE, WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**H
*
CALL ZTRMM( 'Right', 'Upper', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C where C = ( C1 )
-* ( C2 )
+* Form H * C or H**H * C where C = ( C1 )
+* ( C2 )
*
LASTV = MAX( K, ILAZLC( K, M, V, LDV ) )
LASTC = ILAZLC( LASTV, N, C, LDC )
*
-* W := C' * V' = (C1'*V1' + C2'*V2') (stored in WORK)
+* W := C**H * V**H = (C1**H * V1**H + C2**H * V2**H) (stored in WORK)
*
-* W := C2'
+* W := C2**H
*
DO 190 J = 1, K
CALL ZCOPY( LASTC, C( LASTV-K+J, 1 ), LDC,
CALL ZLACGV( LASTC, WORK( 1, J ), 1 )
190 CONTINUE
*
-* W := W * V2'
+* W := W * V2**H
*
CALL ZTRMM( 'Right', 'Lower', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1'*V1'
+* W := W + C1**H * V1**H
*
CALL ZGEMM( 'Conjugate transpose',
$ 'Conjugate transpose', LASTC, K, LASTV-K,
$ ONE, C, LDC, V, LDV, ONE, WORK, LDWORK )
END IF
*
-* W := W * T' or W * T
+* W := W * T**H or W * T
*
CALL ZTRMM( 'Right', 'Lower', TRANST, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
*
-* C := C - V' * W'
+* C := C - V**H * W**H
*
IF( LASTV.GT.K ) THEN
*
-* C1 := C1 - V1' * W'
+* C1 := C1 - V1**H * W**H
*
CALL ZGEMM( 'Conjugate transpose',
$ 'Conjugate transpose', LASTV-K, LASTC, K,
$ LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
*
-* C2 := C2 - W'
+* C2 := C2 - W**H
*
DO 210 J = 1, K
DO 200 I = 1, LASTC
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H' where C = ( C1 C2 )
+* Form C * H or C * H**H where C = ( C1 C2 )
*
LASTV = MAX( K, ILAZLC( K, N, V, LDV ) )
LASTC = ILAZLR( M, LASTV, C, LDC )
*
-* W := C * V' = (C1*V1' + C2*V2') (stored in WORK)
+* W := C * V**H = (C1*V1**H + C2*V2**H) (stored in WORK)
*
* W := C2
*
$ WORK( 1, J ), 1 )
220 CONTINUE
*
-* W := W * V2'
+* W := W * V2**H
*
CALL ZTRMM( 'Right', 'Lower', 'Conjugate transpose',
$ 'Unit', LASTC, K, ONE, V( 1, LASTV-K+1 ), LDV,
$ WORK, LDWORK )
IF( LASTV.GT.K ) THEN
*
-* W := W + C1 * V1'
+* W := W + C1 * V1**H
*
CALL ZGEMM( 'No transpose', 'Conjugate transpose',
$ LASTC, K, LASTV-K, ONE, C, LDC, V, LDV, ONE,
$ WORK, LDWORK )
END IF
*
-* W := W * T or W * T'
+* W := W * T or W * T**H
*
CALL ZTRMM( 'Right', 'Lower', TRANS, 'Non-unit',
$ LASTC, K, ONE, T, LDT, WORK, LDWORK )
* ZLARFG generates a complex elementary reflector H of order n, such
* that
*
-* H' * ( alpha ) = ( beta ), H' * H = I.
-* ( x ) ( 0 )
+* H**H * ( alpha ) = ( beta ), H**H * H = I.
+* ( x ) ( 0 )
*
* where alpha and beta are scalars, with beta real, and x is an
* (n-1)-element complex vector. H is represented in the form
*
-* H = I - tau * ( 1 ) * ( 1 v' ) ,
+* H = I - tau * ( 1 ) * ( 1 v**H ) ,
* ( v )
*
* where tau is a complex scalar and v is a complex (n-1)-element
* ZLARFGP generates a complex elementary reflector H of order n, such
* that
*
-* H' * ( alpha ) = ( beta ), H' * H = I.
-* ( x ) ( 0 )
+* H**H * ( alpha ) = ( beta ), H**H * H = I.
+* ( x ) ( 0 )
*
* where alpha and beta are scalars, beta is real and non-negative, and
* x is an (n-1)-element complex vector. H is represented in the form
*
-* H = I - tau * ( 1 ) * ( 1 v' ) ,
+* H = I - tau * ( 1 ) * ( 1 v**H ) ,
* ( v )
*
* where tau is a complex scalar and v is a complex (n-1)-element
* 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
*
* Arguments
* =========
END DO
J = MIN( LASTV, PREVLASTV )
*
-* T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)' * V(i:j,i)
+* T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)**H * V(i:j,i)
*
CALL ZGEMV( 'Conjugate transpose', J-I+1, I-1,
$ -TAU( I ), V( I, 1 ), LDV, V( I, I ), 1,
END DO
J = MIN( LASTV, PREVLASTV )
*
-* T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)'
+* T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)**H
*
IF( I.LT.J )
$ CALL ZLACGV( J-I, V( I, I+1 ), LDV )
J = MAX( LASTV, PREVLASTV )
*
* T(i+1:k,i) :=
-* - tau(i) * V(j:n-k+i,i+1:k)' * V(j:n-k+i,i)
+* - tau(i) * V(j:n-k+i,i+1:k)**H * V(j:n-k+i,i)
*
CALL ZGEMV( 'Conjugate transpose', N-K+I-J+1, K-I,
$ -TAU( I ), V( J, I+1 ), LDV, V( J, I ),
J = MAX( LASTV, PREVLASTV )
*
* T(i+1:k,i) :=
-* - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)'
+* - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)**H
*
CALL ZLACGV( N-K+I-1-J+1, V( I, J ), LDV )
CALL ZGEMV( 'No transpose', K-I, N-K+I-J+1,
* matrix C, from either the left or the right. H is represented in the
* form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**H
*
* where tau is a complex scalar and v is a complex vector.
*
* =======
*
* ZLARRV computes the eigenvectors of the tridiagonal matrix
-* T = L D L^T given L, D and APPROXIMATIONS to the eigenvalues of L D L^T.
+* T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T.
* The input eigenvalues should have been computed by DLARRE.
*
* Arguments
* M-by-N matrix C, from either the left or the right. H is represented
* in the form
*
-* H = I - tau * v * v'
+* H = I - tau * v * v**H
*
* where tau is a complex scalar and v is a complex vector.
*
* If tau = 0, then H is taken to be the unit matrix.
*
-* To apply H' (the conjugate transpose of H), supply conjg(tau) instead
+* To apply H**H (the conjugate transpose of H), supply conjg(tau) instead
* tau.
*
* H is a product of k elementary reflectors as returned by ZTZRZF.
CALL ZCOPY( N, C, LDC, WORK, 1 )
CALL ZLACGV( N, WORK, 1 )
*
-* w( 1:n ) = conjg( w( 1:n ) + C( m-l+1:m, 1:n )' * v( 1:l ) )
+* w( 1:n ) = conjg( w( 1:n ) + C( m-l+1:m, 1:n )**H * v( 1:l ) )
*
CALL ZGEMV( 'Conjugate transpose', L, N, ONE, C( M-L+1, 1 ),
$ LDC, V, INCV, ONE, WORK, 1 )
CALL ZAXPY( N, -TAU, WORK, 1, C, LDC )
*
* C( m-l+1:m, 1:n ) = C( m-l+1:m, 1:n ) - ...
-* tau * v( 1:l ) * conjg( w( 1:n )' )
+* tau * v( 1:l ) * w( 1:n )**H
*
CALL ZGERU( L, N, -TAU, V, INCV, WORK, 1, C( M-L+1, 1 ),
$ LDC )
CALL ZAXPY( M, -TAU, WORK, 1, C, 1 )
*
* C( 1:m, n-l+1:n ) = C( 1:m, n-l+1:n ) - ...
-* tau * w( 1:m ) * v( 1:l )'
+* tau * w( 1:m ) * v( 1:l )**H
*
CALL ZGERC( M, L, -TAU, WORK, 1, V, INCV, C( 1, N-L+1 ),
$ LDC )
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply H or H' from the Left
-* = 'R': apply H or H' from the Right
+* = 'L': apply H or H**H from the Left
+* = 'R': apply H or H**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply H (No transpose)
-* = 'C': apply H' (Conjugate transpose)
+* = 'C': apply H**H (Conjugate transpose)
*
* DIRECT (input) CHARACTER*1
* Indicates how H is formed from a product of elementary
*
* C (input/output) COMPLEX*16 array, dimension (LDC,N)
* On entry, the M-by-N matrix C.
-* On exit, C is overwritten by H*C or H'*C or C*H or C*H'.
+* On exit, C is overwritten by H*C or H**H*C or C*H or C*H**H.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* Form H * C or H' * C
+* Form H * C or H**H * C
*
-* W( 1:n, 1:k ) = conjg( C( 1:k, 1:n )' )
+* W( 1:n, 1:k ) = C( 1:k, 1:n )**H
*
DO 10 J = 1, K
CALL ZCOPY( N, C( J, 1 ), LDC, WORK( 1, J ), 1 )
10 CONTINUE
*
* W( 1:n, 1:k ) = W( 1:n, 1:k ) + ...
-* conjg( C( m-l+1:m, 1:n )' ) * V( 1:k, 1:l )'
+* C( m-l+1:m, 1:n )**H * V( 1:k, 1:l )**T
*
IF( L.GT.0 )
$ CALL ZGEMM( 'Transpose', 'Conjugate 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 ZTRMM( 'Right', 'Lower', TRANST, 'Non-unit', N, K, ONE, T,
$ LDT, WORK, LDWORK )
*
-* C( 1:k, 1:n ) = C( 1:k, 1:n ) - conjg( W( 1:n, 1:k )' )
+* C( 1:k, 1:n ) = C( 1:k, 1:n ) - W( 1:n, 1:k )**H
*
DO 30 J = 1, N
DO 20 I = 1, K
30 CONTINUE
*
* C( m-l+1:m, 1:n ) = C( m-l+1:m, 1:n ) - ...
-* conjg( V( 1:k, 1:l )' ) * conjg( W( 1:n, 1:k )' )
+* V( 1:k, 1:l )**H * W( 1:n, 1:k )**H
*
IF( L.GT.0 )
$ CALL ZGEMM( 'Transpose', 'Transpose', L, N, K, -ONE, V, LDV,
*
ELSE IF( LSAME( SIDE, 'R' ) ) THEN
*
-* Form C * H or C * H'
+* Form C * H or C * H**H
*
* W( 1:m, 1:k ) = C( 1:m, 1:k )
*
40 CONTINUE
*
* W( 1:m, 1:k ) = W( 1:m, 1:k ) + ...
-* C( 1:m, n-l+1:n ) * conjg( V( 1:k, 1:l )' )
+* C( 1:m, n-l+1:n ) * V( 1:k, 1:l )**H
*
IF( L.GT.0 )
$ CALL ZGEMM( 'No transpose', 'Transpose', M, K, L, ONE,
$ C( 1, N-L+1 ), LDC, V, LDV, ONE, WORK, LDWORK )
*
* W( 1:m, 1:k ) = W( 1:m, 1:k ) * conjg( T ) or
-* W( 1:m, 1:k ) * conjg( T' )
+* W( 1:m, 1:k ) * T**H
*
DO 50 J = 1, K
CALL ZLACGV( K-J+1, T( J, J ), 1 )
*
IF( I.LT.K ) THEN
*
-* T(i+1:k,i) = - tau(i) * V(i+1:k,1:n) * V(i,1:n)'
+* T(i+1:k,i) = - tau(i) * V(i+1:k,1:n) * V(i,1:n)**H
*
CALL ZLACGV( N, V( I, 1 ), LDV )
CALL ZGEMV( 'No transpose', K-I, N, -TAU( I ),
* A using the Bunch-Kaufman diagonal pivoting method. The partial
* factorization has the form:
*
-* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
-* ( 0 U22 ) ( 0 D ) ( U12' U22' )
+* A = ( I U12 ) ( A11 0 ) ( I 0 ) if UPLO = 'U', or:
+* ( 0 U22 ) ( 0 D ) ( U12**T U22**T )
*
-* A = ( L11 0 ) ( D 0 ) ( L11' L21' ) if UPLO = 'L'
-* ( L21 I ) ( 0 A22 ) ( 0 I )
+* A = ( L11 0 ) ( D 0 ) ( L11**T L21**T ) if UPLO = 'L'
+* ( L21 I ) ( 0 A22 ) ( 0 I )
*
* where the order of D is at most NB. The actual order is returned in
* the argument KB, and is either NB or NB-1, or N if N <= NB.
-* Note that U' denotes the transpose of U.
+* Note that U**T denotes the transpose of U.
*
* ZLASYF is an auxiliary routine called by ZSYTRF. It uses blocked code
* (calling Level 3 BLAS) to update the submatrix A11 (if UPLO = 'U') or
*
* Update the upper triangle of A11 (= A(1:k,1:k)) as
*
-* A11 := A11 - U12*D*U12' = A11 - U12*W'
+* A11 := A11 - U12*D*U12**T = A11 - U12*W**T
*
* computing blocks of NB columns at a time
*
*
* Update the lower triangle of A22 (= A(k:n,k:n)) as
*
-* A22 := A22 - L21*D*L21' = A22 - L21*W'
+* A22 := A22 - L21*D*L21**T = A22 - L21*W**T
*
* computing blocks of NB columns at a time
*
*
* ZLATRD reduces NB rows and columns of a complex Hermitian matrix A to
* Hermitian tridiagonal form by a unitary similarity
-* transformation Q' * A * Q, and returns the matrices V and W which are
+* transformation Q**H * A * Q, and returns the matrices V and W which are
* needed to apply the transformation to the unreduced part of A.
*
* If UPLO = 'U', ZLATRD reduces the last NB rows and columns of a
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(i:n) = 0 and v(i-1) = 1; v(1:i-1) is stored on exit in A(1:i-1,i),
*
* Each H(i) has the form
*
-* H(i) = I - tau * v * v'
+* H(i) = I - tau * v * v**H
*
* where tau is a complex scalar, and v is a complex vector with
* v(1:i) = 0 and v(i+1) = 1; v(i+1:n) is stored on exit in A(i+1:n,i),
* The elements of the vectors v together form the n-by-nb matrix V
* which is needed, with W, to apply the transformation to the unreduced
* part of the matrix, using a Hermitian rank-2k update of the form:
-* A := A - V*W' - W*V'.
+* A := A - V*W**H - W*V**H.
*
* The contents of A on exit are illustrated by the following examples
* with n = 5 and nb = 2:
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
+* T( k ) = I - tau*u( k )*u( k )**H, u( k ) = ( 1 ),
* ( 0 )
* ( z( k ) )
*
*
* ZLATZM applies a Householder matrix generated by ZTZRQF to a matrix.
*
-* Let P = I - tau*u*u', u = ( 1 ),
-* ( v )
+* Let P = I - tau*u*u**H, u = ( 1 ),
+* ( v )
* where v is an (m-1) vector if SIDE = 'L', or a (n-1) vector if
* SIDE = 'R'.
*
*
IF( LSAME( SIDE, 'L' ) ) THEN
*
-* w := conjg( C1 + v' * C2 )
+* w := ( C1 + v**H * C2 )**H
*
CALL ZCOPY( N, C1, LDC, WORK, 1 )
CALL ZLACGV( N, WORK, 1 )
CALL ZGEMV( 'Conjugate transpose', M-1, N, ONE, C2, LDC, V,
$ INCV, ONE, WORK, 1 )
*
-* [ C1 ] := [ C1 ] - tau* [ 1 ] * w'
+* [ C1 ] := [ C1 ] - tau* [ 1 ] * w**H
* [ C2 ] [ C2 ] [ v ]
*
CALL ZLACGV( N, WORK, 1 )
CALL ZGEMV( 'No transpose', M, N-1, ONE, C2, LDC, V, INCV, ONE,
$ WORK, 1 )
*
-* [ C1, C2 ] := [ C1, C2 ] - tau* w * [ 1 , v']
+* [ C1, C2 ] := [ C1, C2 ] - tau* w * [ 1 , v**H]
*
CALL ZAXPY( M, -TAU, WORK, 1, C1, 1 )
CALL ZGERC( M, N-1, -TAU, WORK, 1, V, INCV, C2, LDC )
* Purpose
* =======
*
-* ZLAUU2 computes the product U * U' or L' * L, where the triangular
+* ZLAUU2 computes the product U * U**H or L**H * L, where the triangular
* factor U or L is stored in the upper or lower triangular part of
* the array A.
*
* A (input/output) COMPLEX*16 array, dimension (LDA,N)
* On entry, the triangular factor U or L.
* On exit, if UPLO = 'U', the upper triangle of A is
-* overwritten with the upper triangle of the product U * U';
+* overwritten with the upper triangle of the product U * U**H;
* if UPLO = 'L', the lower triangle of A is overwritten with
-* the lower triangle of the product L' * L.
+* the lower triangle of the product L**H * L.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the product U * U'.
+* Compute the product U * U**H.
*
DO 10 I = 1, N
AII = A( I, I )
*
ELSE
*
-* Compute the product L' * L.
+* Compute the product L**H * L.
*
DO 20 I = 1, N
AII = A( I, I )
* Purpose
* =======
*
-* ZLAUUM computes the product U * U' or L' * L, where the triangular
+* ZLAUUM computes the product U * U**H or L**H * L, where the triangular
* factor U or L is stored in the upper or lower triangular part of
* the array A.
*
* A (input/output) COMPLEX*16 array, dimension (LDA,N)
* On entry, the triangular factor U or L.
* On exit, if UPLO = 'U', the upper triangle of A is
-* overwritten with the upper triangle of the product U * U';
+* overwritten with the upper triangle of the product U * U**H;
* if UPLO = 'L', the lower triangle of A is overwritten with
-* the lower triangle of the product L' * L.
+* the lower triangle of the product L**H * L.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the product U * U'.
+* Compute the product U * U**H.
*
DO 10 I = 1, N, NB
IB = MIN( NB, N-I+1 )
10 CONTINUE
ELSE
*
-* Compute the product L' * L.
+* Compute the product L**H * L.
*
DO 20 I = 1, N, NB
IB = MIN( NB, N-I+1 )
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**H).
*
CALL ZLATBS( 'Upper', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, KD, AB, LDAB, WORK, SCALEL, RWORK,
$ KD, AB, LDAB, WORK, SCALEL, RWORK, INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**H).
*
CALL ZLATBS( 'Lower', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, KD, AB, LDAB, WORK, SCALEU, RWORK,
* See below for further details.
*
* On exit, if INFO = 0, the triangular factor U or L from the
-* Cholesky factorization A = U**H*U or A = L*L**H of the band
+* Cholesky factorization A = U**H *U or A = L*L**H of the band
* matrix A, in the same storage format as A.
*
* LDAB (input) INTEGER
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H *U or A = L*L**H.
*
CALL ZPBTRF( UPLO, N, KD, AB, LDAB, INFO )
IF( INFO.EQ.0 ) THEN
* AFB (input or output) COMPLEX*16 array, dimension (LDAFB,N)
* If FACT = 'F', then AFB is an input argument and on entry
* contains the triangular factor U or L from the Cholesky
-* factorization A = U**H*U or A = L*L**H of the band matrix
+* factorization A = U**H *U or A = L*L**H of the band matrix
* A, in the same storage format as A (see AB). If EQUED = 'Y',
* then AFB is the factored form of the equilibrated matrix A.
*
* If FACT = 'N', then AFB is an output argument and on exit
* returns the triangular factor U or L from the Cholesky
-* factorization A = U**H*U or A = L*L**H.
+* factorization A = U**H *U or A = L*L**H.
*
* If FACT = 'E', then AFB is an output argument and on exit
* returns the triangular factor U or L from the Cholesky
-* factorization A = U**H*U or A = L*L**H of the equilibrated
+* factorization A = U**H *U or A = L*L**H of the equilibrated
* matrix A (see the description of A for the form of the
* equilibrated matrix).
*
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H *U or A = L*L**H.
*
IF( UPPER ) THEN
DO 40 J = 1, N
* positive definite band matrix A.
*
* The factorization has the form
-* A = U' * U , if UPLO = 'U', or
-* A = L * L', if UPLO = 'L',
-* where U is an upper triangular matrix, U' is the conjugate transpose
+* A = U**H * U , if UPLO = 'U', or
+* A = L * L**H, if UPLO = 'L',
+* where U is an upper triangular matrix, U**H is the conjugate transpose
* of U, and L is lower triangular.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
*
* On exit, if INFO = 0, the triangular factor U or L from the
-* Cholesky factorization A = U'*U or A = L*L' of the band
+* Cholesky factorization A = U**H *U or A = L*L**H of the band
* matrix A, in the same storage format as A.
*
* LDAB (input) INTEGER
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**H * U.
*
DO 10 J = 1, N
*
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**H.
*
DO 20 J = 1, N
*
*
* ZPBTRS solves a system of linear equations A*X = B with a Hermitian
* positive definite band matrix A using the Cholesky factorization
-* A = U**H*U or A = L*L**H computed by ZPBTRF.
+* A = U**H *U or A = L*L**H computed by ZPBTRF.
*
* Arguments
* =========
*
* AB (input) COMPLEX*16 array, dimension (LDAB,N)
* The triangular factor U or L from the Cholesky factorization
-* A = U**H*U or A = L*L**H of the band matrix A, stored in the
+* A = U**H *U or A = L*L**H of the band matrix A, stored in the
* first KD+1 rows of the array. The j-th column of U or L is
* stored in the j-th column of the array AB as follows:
* if UPLO ='U', AB(kd+1+i-j,j) = U(i,j) for max(1,j-kd)<=i<=j;
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**H *U.
*
DO 10 J = 1, NRHS
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**H *X = B, overwriting B with X.
*
CALL ZTBSV( 'Upper', 'Conjugate transpose', 'Non-unit', N,
$ KD, AB, LDAB, B( 1, J ), 1 )
10 CONTINUE
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L*L**H.
*
DO 20 J = 1, NRHS
*
CALL ZTBSV( 'Lower', 'No transpose', 'Non-unit', N, KD, AB,
$ LDAB, B( 1, J ), 1 )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**H *X = B, overwriting B with X.
*
CALL ZTBSV( 'Lower', 'Conjugate transpose', 'Non-unit', N,
$ KD, AB, LDAB, B( 1, J ), 1 )
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**H).
*
CALL ZLATRS( 'Upper', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, A, LDA, WORK, SCALEL, RWORK, INFO )
$ A, LDA, WORK, SCALEL, RWORK, INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**H).
*
CALL ZLATRS( 'Lower', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, A, LDA, WORK, SCALEU, RWORK, INFO )
* triangular part of A is not referenced.
*
* On exit, if INFO = 0, the factor U or L from the Cholesky
-* factorization A = U**H*U or A = L*L**H.
+* factorization A = U**H *U or A = L*L**H.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H *U or A = L*L**H.
*
CALL ZPOTRF( UPLO, N, A, LDA, INFO )
IF( INFO.EQ.0 ) THEN
* AF (input or output) COMPLEX*16 array, dimension (LDAF,N)
* If FACT = 'F', then AF is an input argument and on entry
* contains the triangular factor U or L from the Cholesky
-* factorization A = U**H*U or A = L*L**H, in the same storage
+* factorization A = U**H *U or A = L*L**H, in the same storage
* format as A. If EQUED .ne. 'N', then AF is the factored form
* of the equilibrated matrix diag(S)*A*diag(S).
*
* If FACT = 'N', then AF is an output argument and on exit
* returns the triangular factor U or L from the Cholesky
-* factorization A = U**H*U or A = L*L**H of the original
+* factorization A = U**H *U or A = L*L**H of the original
* matrix A.
*
* If FACT = 'E', then AF is an output argument and on exit
* returns the triangular factor U or L from the Cholesky
-* factorization A = U**H*U or A = L*L**H of the equilibrated
+* factorization A = U**H *U or A = L*L**H of the equilibrated
* matrix A (see the description of A for the form of the
* equilibrated matrix).
*
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H *U or A = L*L**H.
*
CALL ZLACPY( UPLO, N, N, A, LDA, AF, LDAF )
CALL ZPOTRF( UPLO, N, AF, LDAF, INFO )
* positive definite matrix A.
*
* The factorization has the form
-* A = U' * U , if UPLO = 'U', or
-* A = L * L', if UPLO = 'L',
+* A = U**H * U , if UPLO = 'U', or
+* A = L * L**H, if UPLO = 'L',
* where U is an upper triangular matrix and L is lower triangular.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* triangular part of A is not referenced.
*
* On exit, if INFO = 0, the factor U or L from the Cholesky
-* factorization A = U'*U or A = L*L'.
+* factorization A = U**H *U or A = L*L**H.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**H *U.
*
DO 10 J = 1, N
*
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**H.
*
DO 20 J = 1, N
*
* triangular part of A is not referenced.
*
* On exit, if INFO = 0, the factor U or L from the Cholesky
-* factorization A = U**H*U or A = L*L**H.
+* factorization A = U**H *U or A = L*L**H.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**H *U.
*
DO 10 J = 1, N, NB
*
*
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L*L**H.
*
DO 20 J = 1, N, NB
*
IF( INFO.GT.0 )
$ RETURN
*
-* Form inv(U)*inv(U)' or inv(L)'*inv(L).
+* Form inv(U) * inv(U)**H or inv(L)**H * inv(L).
*
CALL ZLAUUM( UPLO, N, A, LDA, INFO )
*
*
* ZPOTRS solves a system of linear equations A*X = B with a Hermitian
* positive definite matrix A using the Cholesky factorization
-* A = U**H*U or A = L*L**H computed by ZPOTRF.
+* A = U**H * U or A = L * L**H computed by ZPOTRF.
*
* Arguments
* =========
*
* A (input) COMPLEX*16 array, dimension (LDA,N)
* The triangular factor U or L from the Cholesky factorization
-* A = U**H*U or A = L*L**H, as computed by ZPOTRF.
+* A = U**H * U or A = L * L**H, as computed by ZPOTRF.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max(1,N).
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**H *U.
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**H *X = B, overwriting B with X.
*
CALL ZTRSM( 'Left', 'Upper', 'Conjugate transpose', 'Non-unit',
$ N, NRHS, ONE, A, LDA, B, LDB )
$ NRHS, ONE, A, LDA, B, LDB )
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L*L**H.
*
* Solve L*X = B, overwriting B with X.
*
CALL ZTRSM( 'Left', 'Lower', 'No transpose', 'Non-unit', N,
$ NRHS, ONE, A, LDA, B, LDB )
*
-* Solve L'*X = B, overwriting B with X.
+* Solve L**H *X = B, overwriting B with X.
*
CALL ZTRSM( 'Left', 'Lower', 'Conjugate transpose', 'Non-unit',
$ N, NRHS, ONE, A, LDA, B, LDB )
IF( KASE.NE.0 ) THEN
IF( UPPER ) THEN
*
-* Multiply by inv(U').
+* Multiply by inv(U**H).
*
CALL ZLATPS( 'Upper', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, AP, WORK, SCALEL, RWORK, INFO )
$ AP, WORK, SCALEL, RWORK, INFO )
NORMIN = 'Y'
*
-* Multiply by inv(L').
+* Multiply by inv(L**H).
*
CALL ZLATPS( 'Lower', 'Conjugate transpose', 'Non-unit',
$ NORMIN, N, AP, WORK, SCALEU, RWORK, INFO )
* packed format and X and B are N-by-NRHS matrices.
*
* The Cholesky decomposition is used to factor A as
-* A = U**H* U, if UPLO = 'U', or
+* A = U**H * U, if UPLO = 'U', or
* A = L * L**H, if UPLO = 'L',
* where U is an upper triangular matrix and L is a lower triangular
* matrix. The factored form of A is then used to solve the system of
RETURN
END IF
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H *U or A = L*L**H.
*
CALL ZPPTRF( UPLO, N, AP, INFO )
IF( INFO.EQ.0 ) THEN
* Purpose
* =======
*
-* ZPPSVX uses the Cholesky factorization A = U**H*U or A = L*L**H to
+* ZPPSVX uses the Cholesky factorization A = U**H * U or A = L * L**H to
* compute the solution to a complex system of linear equations
* A * X = B,
* where A is an N-by-N Hermitian positive definite matrix stored in
*
* 2. If FACT = 'N' or 'E', the Cholesky decomposition is used to
* factor the matrix A (after equilibration if FACT = 'E') as
-* A = U'* U , if UPLO = 'U', or
-* A = L * L', if UPLO = 'L',
+* 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.
*
*
* If FACT = 'N', then AFP is an output argument and on exit
* returns the triangular factor U or L from the Cholesky
-* factorization A = U**H*U or A = L*L**H of the original
+* factorization A = U**H * U or A = L * L**H of the original
* matrix A.
*
* If FACT = 'E', then AFP is an output argument and on exit
* returns the triangular factor U or L from the Cholesky
-* factorization A = U**H*U or A = L*L**H of the equilibrated
+* factorization A = U**H * U or A = L * L**H of the equilibrated
* matrix A (see the description of AP for the form of the
* equilibrated matrix).
*
*
IF( NOFACT .OR. EQUIL ) THEN
*
-* Compute the Cholesky factorization A = U'*U or A = L*L'.
+* Compute the Cholesky factorization A = U**H * U or A = L * L**H.
*
CALL ZCOPY( N*( N+1 ) / 2, AP, 1, AFP, 1 )
CALL ZPPTRF( UPLO, N, AFP, INFO )
*
IF( UPPER ) THEN
*
-* Compute the Cholesky factorization A = U'*U.
+* Compute the Cholesky factorization A = U**H * U.
*
JJ = 0
DO 10 J = 1, N
10 CONTINUE
ELSE
*
-* Compute the Cholesky factorization A = L*L'.
+* Compute the Cholesky factorization A = L * L**H.
*
JJ = 1
DO 20 J = 1, N
$ RETURN
IF( UPPER ) THEN
*
-* Compute the product inv(U) * inv(U)'.
+* Compute the product inv(U) * inv(U)**H.
*
JJ = 0
DO 10 J = 1, N
*
ELSE
*
-* Compute the product inv(L)' * inv(L).
+* Compute the product inv(L)**H * inv(L).
*
JJ = 1
DO 20 J = 1, N
*
* ZPPTRS solves a system of linear equations A*X = B with a Hermitian
* positive definite matrix A in packed storage using the Cholesky
-* factorization A = U**H*U or A = L*L**H computed by ZPPTRF.
+* factorization A = U**H * U or A = L * L**H computed by ZPPTRF.
*
* Arguments
* =========
*
* AP (input) COMPLEX*16 array, dimension (N*(N+1)/2)
* The triangular factor U or L from the Cholesky factorization
-* A = U**H*U or A = L*L**H, packed columnwise in a linear
+* A = U**H * U or A = L * L**H, packed columnwise in a linear
* array. The j-th column of U or L is stored in the array AP
* as follows:
* if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;
*
IF( UPPER ) THEN
*
-* Solve A*X = B where A = U'*U.
+* Solve A*X = B where A = U**H * U.
*
DO 10 I = 1, NRHS
*
-* Solve U'*X = B, overwriting B with X.
+* Solve U**H *X = B, overwriting B with X.
*
CALL ZTPSV( 'Upper', 'Conjugate transpose', 'Non-unit', N,
$ AP, B( 1, I ), 1 )
10 CONTINUE
ELSE
*
-* Solve A*X = B where A = L*L'.
+* Solve A*X = B where A = L * L**H.
*
DO 20 I = 1, NRHS
*
CALL ZTPSV( 'Lower', 'No transpose', 'Non-unit', N, AP,
$ B( 1, I ), 1 )
*
-* Solve L'*X = Y, overwriting B with X.
+* Solve L**H *X = Y, overwriting B with X.
*
CALL ZTPSV( 'Lower', 'Conjugate transpose', 'Non-unit', N,
$ AP, B( 1, I ), 1 )
* 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)'.
+* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**H.
*
* Solve M(L) * x = e.
*
RWORK( I ) = ONE + RWORK( I-1 )*ABS( E( I-1 ) )
20 CONTINUE
*
-* Solve D * M(L)' * x = b.
+* Solve D * M(L)**H * x = b.
*
RWORK( N ) = RWORK( N ) / D( N )
DO 30 I = N - 1, 1, -1
* 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)'.
+* and e = [ 1, 1, ..., 1 ]'. Note M(A) = M(L)*D*M(L)**H.
*
* Solve M(L) * x = e.
*
RWORK( I ) = ONE + RWORK( I-1 )*ABS( EF( I-1 ) )
70 CONTINUE
*
-* Solve D * M(L)' * x = b.
+* Solve D * M(L)**H * x = b.
*
RWORK( N ) = RWORK( N ) / DF( N )
DO 80 I = N - 1, 1, -1
* A. E can also be regarded as the superdiagonal of the unit
* bidiagonal factor U from the U**H*D*U factorization of A.
*
-* B (input/output) COMPLEX*16 array, dimension (LDB,N)
+* B (input/output) COMPLEX*16 array, dimension (LDB,NRHS)
* On entry, the N-by-NRHS right hand side matrix B.
* On exit, if INFO = 0, the N-by-NRHS solution matrix X.
*
RETURN
END IF
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**H (or U**H*D*U) factorization of A.
*
CALL ZPTTRF( N, D, E, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**H (or U**H*D*U) factorization of A.
*
CALL DCOPY( N, D, 1, DF, 1 )
IF( N.GT.1 )
* Purpose
* =======
*
-* ZPTTRF computes the L*D*L' factorization of a complex Hermitian
+* ZPTTRF computes the L*D*L**H factorization of a complex Hermitian
* positive definite tridiagonal matrix A. The factorization may also
-* be regarded as having the form A = U'*D*U.
+* be regarded as having the form A = U**H *D*U.
*
* Arguments
* =========
* D (input/output) DOUBLE PRECISION array, dimension (N)
* On entry, the n diagonal elements of the tridiagonal matrix
* A. On exit, the n diagonal elements of the diagonal matrix
-* D from the L*D*L' factorization of A.
+* D from the L*D*L**H factorization of A.
*
* E (input/output) COMPLEX*16 array, dimension (N-1)
* On entry, the (n-1) subdiagonal elements of the tridiagonal
* matrix A. On exit, the (n-1) subdiagonal elements of the
-* unit bidiagonal factor L from the L*D*L' factorization of A.
+* unit bidiagonal factor L from the L*D*L**H factorization of A.
* E can also be regarded as the superdiagonal of the unit
-* bidiagonal factor U from the U'*D*U factorization of A.
+* bidiagonal factor U from the U**H *D*U factorization of A.
*
* INFO (output) INTEGER
* = 0: successful exit
IF( N.EQ.0 )
$ RETURN
*
-* Compute the L*D*L' (or U'*D*U) factorization of A.
+* Compute the L*D*L**H (or U**H *D*U) factorization of A.
*
I4 = MOD( N-1, 4 )
DO 10 I = 1, I4
*
* ZPTTRS solves a tridiagonal system of the form
* A * X = B
-* using the factorization A = U'*D*U or A = L*D*L' computed by ZPTTRF.
+* using the factorization A = U**H *D* U or A = L*D*L**H computed by ZPTTRF.
* D is a diagonal matrix specified in the vector D, U (or L) is a unit
* bidiagonal matrix whose superdiagonal (subdiagonal) is specified in
* the vector E, and X and B are N by NRHS matrices.
* Specifies the form of the factorization and whether the
* vector E is the superdiagonal of the upper bidiagonal factor
* U or the subdiagonal of the lower bidiagonal factor L.
-* = 'U': A = U'*D*U, E is the superdiagonal of U
-* = 'L': A = L*D*L', E is the subdiagonal of L
+* = 'U': A = U**H *D*U, E is the superdiagonal of U
+* = 'L': A = L*D*L**H, E is the subdiagonal of L
*
* N (input) INTEGER
* The order of the tridiagonal matrix A. N >= 0.
*
* D (input) DOUBLE PRECISION array, dimension (N)
* The n diagonal elements of the diagonal matrix D from the
-* factorization A = U'*D*U or A = L*D*L'.
+* factorization A = U**H *D*U or A = L*D*L**H.
*
* E (input) COMPLEX*16 array, dimension (N-1)
* If UPLO = 'U', the (n-1) superdiagonal elements of the unit
-* bidiagonal factor U from the factorization A = U'*D*U.
+* bidiagonal factor U from the factorization A = U**H*D*U.
* If UPLO = 'L', the (n-1) subdiagonal elements of the unit
-* bidiagonal factor L from the factorization A = L*D*L'.
+* bidiagonal factor L from the factorization A = L*D*L**H.
*
* B (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS)
* On entry, the right hand side vectors B for the system of
*
* ZPTTS2 solves a tridiagonal system of the form
* A * X = B
-* using the factorization A = U'*D*U or A = L*D*L' computed by ZPTTRF.
+* using the factorization A = U**H *D*U or A = L*D*L**H computed by ZPTTRF.
* D is a diagonal matrix specified in the vector D, U (or L) is a unit
* bidiagonal matrix whose superdiagonal (subdiagonal) is specified in
* the vector E, and X and B are N by NRHS matrices.
* Specifies the form of the factorization and whether the
* vector E is the superdiagonal of the upper bidiagonal factor
* U or the subdiagonal of the lower bidiagonal factor L.
-* = 1: A = U'*D*U, E is the superdiagonal of U
-* = 0: A = L*D*L', E is the subdiagonal of L
+* = 1: A = U**H *D*U, E is the superdiagonal of U
+* = 0: A = L*D*L**H, E is the subdiagonal of L
*
* N (input) INTEGER
* The order of the tridiagonal matrix A. N >= 0.
*
* D (input) DOUBLE PRECISION array, dimension (N)
* The n diagonal elements of the diagonal matrix D from the
-* factorization A = U'*D*U or A = L*D*L'.
+* factorization A = U**H *D*U or A = L*D*L**H.
*
* E (input) COMPLEX*16 array, dimension (N-1)
* If IUPLO = 1, the (n-1) superdiagonal elements of the unit
-* bidiagonal factor U from the factorization A = U'*D*U.
+* bidiagonal factor U from the factorization A = U**H*D*U.
* If IUPLO = 0, the (n-1) subdiagonal elements of the unit
-* bidiagonal factor L from the factorization A = L*D*L'.
+* bidiagonal factor L from the factorization A = L*D*L**H.
*
* B (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS)
* On entry, the right hand side vectors B for the system of
*
IF( IUPLO.EQ.1 ) THEN
*
-* Solve A * X = B using the factorization A = U'*D*U,
+* Solve A * X = B using the factorization A = U**H *D*U,
* overwriting each right hand side vector with its solution.
*
IF( NRHS.LE.2 ) THEN
J = 1
10 CONTINUE
*
-* Solve U' * x = b.
+* Solve U**H * x = b.
*
DO 20 I = 2, N
B( I, J ) = B( I, J ) - B( I-1, J )*DCONJG( E( I-1 ) )
ELSE
DO 70 J = 1, NRHS
*
-* Solve U' * x = b.
+* Solve U**H * x = b.
*
DO 50 I = 2, N
B( I, J ) = B( I, J ) - B( I-1, J )*DCONJG( E( I-1 ) )
END IF
ELSE
*
-* Solve A * X = B using the factorization A = L*D*L',
+* Solve A * X = B using the factorization A = L*D*L**H,
* overwriting each right hand side vector with its solution.
*
IF( NRHS.LE.2 ) THEN
B( I, J ) = B( I, J ) - B( I-1, J )*E( I-1 )
90 CONTINUE
*
-* Solve D * L' * x = b.
+* Solve D * L**H * x = b.
*
DO 100 I = 1, N
B( I, J ) = B( I, J ) / D( I )
B( I, J ) = B( I, J ) - B( I-1, J )*E( I-1 )
120 CONTINUE
*
-* Solve D * L' * x = b.
+* Solve D * L**H * x = b.
*
B( N, J ) = B( N, J ) / D( N )
DO 130 I = N - 1, 1, -1
CALL ZLACN2( N, WORK( N+1 ), WORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**T) or inv(U*D*U**T).
*
CALL ZSPTRS( UPLO, N, 1, AP, IPIV, WORK, N, INFO )
GO TO 30
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL ZSPTRF( UPLO, N, AP, IPIV, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL ZCOPY( N*( N+1 ) / 2, AP, 1, AFP, 1 )
CALL ZSPTRF( UPLO, N, AFP, IPIV, INFO )
* 5-96 - Based on modifications by J. Lewis, Boeing Computer Services
* Company
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**T = A - W(k)*1/D(k)*W(k)**T
*
R1 = CONE / AP( KC+K-1 )
CALL ZSPR( UPLO, K-1, -R1, AP( KC ), 1, AP )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**T
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**T
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**T = A - W(k)*(1/D(k))*W(k)**T
*
R1 = CONE / AP( KC )
CALL ZSPR( UPLO, N-K, -R1, AP( KC+1 ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )'
-* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )'
+* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )**T
+* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )**T
*
* where L(k) and L(k+1) are the k-th and (k+1)-th
* columns of L
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**T.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**T*X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**T(K)), where U(K) is the transformation
* stored in column K of A.
*
CALL ZGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, AP( KC ),
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**T(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
CALL ZGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, AP( KC ),
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**T.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**T*X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**T(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N )
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**T(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
CALL ZLACN2( N, WORK( N+1 ), WORK, AINVNM, KASE, ISAVE )
IF( KASE.NE.0 ) THEN
*
-* Multiply by inv(L*D*L') or inv(U*D*U').
+* Multiply by inv(L*D*L**T) or inv(U*D*U**T).
*
CALL ZSYTRS( UPLO, N, 1, A, LDA, IPIV, WORK, N, INFO )
GO TO 30
RETURN
END IF
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL ZSYTRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
IF( INFO.EQ.0 ) THEN
*
IF( NOFACT ) THEN
*
-* Compute the factorization A = U*D*U' or A = L*D*L'.
+* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL ZLACPY( UPLO, N, N, A, LDA, AF, LDAF )
CALL ZSYTRF( UPLO, N, AF, LDAF, IPIV, WORK, LWORK, INFO )
* ZSYTF2 computes the factorization of a complex symmetric matrix A
* using the Bunch-Kaufman diagonal pivoting method:
*
-* A = U*D*U' or A = L*D*L'
+* A = U*D*U**T or A = L*D*L**T
*
* where U (or L) is a product of permutation and unit upper (lower)
-* triangular matrices, U' is the transpose of U, and D is symmetric and
+* triangular matrices, U**T is the transpose of U, and D is symmetric and
* block diagonal with 1-by-1 and 2-by-2 diagonal blocks.
*
* This is the unblocked version of the algorithm, calling Level 2 BLAS.
* 1-96 - Based on modifications by J. Lewis, Boeing Computer Services
* Company
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2
*
IF( MAX( ABSAKK, COLMAX ).EQ.ZERO .OR. DISNAN(ABSAKK) ) THEN
*
-* Column K is zero or contains a NaN: set INFO and continue
+* Column K is zero or NaN: set INFO and continue
*
IF( INFO.EQ.0 )
$ INFO = K
*
* Perform a rank-1 update of A(1:k-1,1:k-1) as
*
-* A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+* A := A - U(k)*D(k)*U(k)**T = A - W(k)*1/D(k)*W(k)**T
*
R1 = CONE / A( K, K )
CALL ZSYR( UPLO, K-1, -R1, A( 1, K ), 1, A, LDA )
*
* Perform a rank-2 update of A(1:k-2,1:k-2) as
*
-* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
-* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+* A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )**T
+* = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )**T
*
IF( K.GT.2 ) THEN
*
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2
*
IF( MAX( ABSAKK, COLMAX ).EQ.ZERO .OR. DISNAN(ABSAKK) ) THEN
*
-* Column K is zero or contains a NaN: set INFO and continue
+* Column K is zero or NaN: set INFO and continue
*
IF( INFO.EQ.0 )
$ INFO = K
*
* Perform a rank-1 update of A(k+1:n,k+1:n) as
*
-* A := A - L(k)*D(k)*L(k)' = A - W(k)*(1/D(k))*W(k)'
+* A := A - L(k)*D(k)*L(k)**T = A - W(k)*(1/D(k))*W(k)**T
*
R1 = CONE / A( K, K )
CALL ZSYR( UPLO, N-K, -R1, A( K+1, K ), 1,
*
* Perform a rank-2 update of A(k+2:n,k+2:n) as
*
-* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )'
-* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )'
+* A := A - ( L(k) L(k+1) )*D(k)*( L(k) L(k+1) )**T
+* = A - ( W(k) W(k+1) )*inv(D(k))*( W(k) W(k+1) )**T
*
* where L(k) and L(k+1) are the k-th and (k+1)-th
* columns of L
* Further Details
* ===============
*
-* If UPLO = 'U', then A = U*D*U', where
+* If UPLO = 'U', then A = U*D*U**T, where
* U = P(n)*U(n)* ... *P(k)U(k)* ...,
* i.e., U is a product of terms P(k)*U(k), where k decreases from n to
* 1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
* If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
* and A(k,k), and v overwrites A(1:k-2,k-1:k).
*
-* If UPLO = 'L', then A = L*D*L', where
+* If UPLO = 'L', then A = L*D*L**T, where
* L = P(1)*L(1)* ... *P(k)*L(k)* ...,
* i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
* n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
*
IF( UPPER ) THEN
*
-* Factorize A as U*D*U' using the upper triangle of A
+* Factorize A as U*D*U**T using the upper triangle of A
*
* K is the main loop index, decreasing from N to 1 in steps of
* KB, where KB is the number of columns factorized by ZLASYF;
*
ELSE
*
-* Factorize A as L*D*L' using the lower triangle of A
+* Factorize A as L*D*L**T using the lower triangle of A
*
* K is the main loop index, increasing from 1 to N in steps of
* KB, where KB is the number of columns factorized by ZLASYF;
*
IF( UPPER ) THEN
*
-* Compute inv(A) from the factorization A = U*D*U'.
+* Compute inv(A) from the factorization A = U*D*U**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
ELSE
*
-* Compute inv(A) from the factorization A = L*D*L'.
+* Compute inv(A) from the factorization A = L*D*L**T.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
IF( UPPER ) THEN
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
*
CALL ZTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**T) = (inv(U))**T
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**T)*inv(D)*inv(U)
*
CUT=N
DO WHILE (CUT .GT. 0)
*
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
*
I=1
DO WHILE ( I .LE. N )
*
* LOWER...
*
-* invA = P * inv(U')*inv(D)*inv(U)*P'.
+* invA = P * inv(U**T)*inv(D)*inv(U)*P'.
*
CALL ZTRTRI( UPLO, 'U', N, A, LDA, INFO )
*
END IF
END DO
*
-* inv(U') = (inv(U))'
+* inv(U**T) = (inv(U))**T
*
-* inv(U')*inv(D)*inv(U)
+* inv(U**T)*inv(D)*inv(U)
*
CUT=0
DO WHILE (CUT .LT. N)
CUT=CUT+NNB
END DO
*
-* Apply PERMUTATIONS P and P': P * inv(U')*inv(D)*inv(U) *P'
+* Apply PERMUTATIONS P and P': P * inv(U**T)*inv(D)*inv(U) *P'
*
I=N
DO WHILE ( I .GE. 1 )
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* Solve A*X = B, where A = U*D*U**T.
*
* First solve U*D*X = B, overwriting B with X.
*
GO TO 10
30 CONTINUE
*
-* Next solve U'*X = B, overwriting B with X.
+* Next solve U**T *X = B, overwriting B with X.
*
* K is the main loop index, increasing from 1 to N in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(U'(K)), where U(K) is the transformation
+* Multiply by inv(U**T(K)), where U(K) is the transformation
* stored in column K of A.
*
CALL ZGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, A( 1, K ),
*
* 2 x 2 diagonal block
*
-* Multiply by inv(U'(K+1)), where U(K+1) is the transformation
+* Multiply by inv(U**T(K+1)), where U(K+1) is the transformation
* stored in columns K and K+1 of A.
*
CALL ZGEMV( 'Transpose', K-1, NRHS, -ONE, B, LDB, A( 1, K ),
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* Solve A*X = B, where A = L*D*L**T.
*
* First solve L*D*X = B, overwriting B with X.
*
GO TO 60
80 CONTINUE
*
-* Next solve L'*X = B, overwriting B with X.
+* Next solve L**T *X = B, overwriting B with X.
*
* K is the main loop index, decreasing from N to 1 in steps of
* 1 or 2, depending on the size of the diagonal blocks.
*
* 1 x 1 diagonal block
*
-* Multiply by inv(L'(K)), where L(K) is the transformation
+* Multiply by inv(L**T(K)), where L(K) is the transformation
* stored in column K of A.
*
IF( K.LT.N )
*
* 2 x 2 diagonal block
*
-* Multiply by inv(L'(K-1)), where L(K-1) is the transformation
+* Multiply by inv(L**T(K-1)), where L(K-1) is the transformation
* stored in columns K-1 and K of A.
*
IF( K.LT.N ) THEN
*
IF( UPPER ) THEN
*
-* Solve A*X = B, where A = U*D*U'.
+* 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
END IF
END DO
*
-* Compute (U \P' * B) -> B [ (U \P' * B) ]
+* Compute (U \P**T * B) -> B [ (U \P**T * B) ]
*
CALL ZTRSM('L','U','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (U \P' * B) ]
+* Compute D \ B -> B [ D \ (U \P**T * B) ]
*
I=N
DO WHILE ( I .GE. 1 )
I = I - 1
END DO
*
-* Compute (U' \ B) -> B [ U' \ (D \ (U \P' * B) ) ]
+* Compute (U**T \ B) -> B [ U**T \ (D \ (U \P**T * B) ) ]
*
CALL ZTRSM('L','U','T','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (U' \ (D \ (U \P' * B) )) ]
+* P * B [ P * (U**T \ (D \ (U \P**T * B) )) ]
*
K=1
DO WHILE ( K .LE. N )
*
ELSE
*
-* Solve A*X = B, where A = L*D*L'.
+* 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
ENDIF
END DO
*
-* Compute (L \P' * B) -> B [ (L \P' * B) ]
+* Compute (L \P**T * B) -> B [ (L \P**T * B) ]
*
CALL ZTRSM('L','L','N','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* Compute D \ B -> B [ D \ (L \P' * B) ]
+* Compute D \ B -> B [ D \ (L \P**T * B) ]
*
I=1
DO WHILE ( I .LE. N )
I = I + 1
END DO
*
-* Compute (L' \ B) -> B [ L' \ (D \ (L \P' * B) ) ]
+* Compute (L**T \ B) -> B [ L**T \ (D \ (L \P**T * B) ) ]
*
CALL ZTRSM('L','L','T','U',N,NRHS,ONE,A,LDA,B,LDB)
*
-* P * B [ P * (L' \ (D \ (L \P' * B) )) ]
+* P * B [ P * (L**T \ (D \ (L \P**T * B) )) ]
*
K=N
DO WHILE ( K .GE. 1 )
* Optionally, the matrices Q and Z of generalized Schur vectors are
* updated.
*
-* Q(in) * A(in) * Z(in)' = Q(out) * A(out) * Z(out)'
-* Q(in) * B(in) * Z(in)' = Q(out) * B(out) * Z(out)'
+* Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H
+* Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H
*
*
* Arguments
IF( WANDS ) THEN
*
* Strong stability test:
-* F-norm((A-QL'*S*QR, B-QL'*T*QR)) <= O(EPS*F-norm((A, B)))
+* F-norm((A-QL**H*S*QR, B-QL**H*T*QR)) <= O(EPS*F-norm((A, B)))
*
CALL ZLACPY( 'Full', M, M, S, LDST, WORK, M )
CALL ZLACPY( 'Full', M, M, T, LDST, WORK( M*M+1 ), M )
* Optionally, the matrices Q and Z of generalized Schur vectors are
* updated.
*
-* Q(in) * A(in) * Z(in)' = Q(out) * A(out) * Z(out)'
-* Q(in) * B(in) * Z(in)' = Q(out) * B(out) * Z(out)'
+* Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H
+* Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H
*
* Arguments
* =========
*
* ZTGSEN reorders the generalized Schur decomposition of a complex
* matrix pair (A, B) (in terms of an unitary equivalence trans-
-* formation Q' * (A, B) * Z), so that a selected cluster of eigenvalues
+* formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues
* appears in the leading diagonal blocks of the pair (A,B). The leading
* columns of Q and Z form unitary bases of the corresponding left and
* right eigenspaces (deflating subspaces). (A, B) must be in
* U and W that move them to the top left corner of (A, B). In other
* words, the selected eigenvalues are the eigenvalues of (A11, B11) in
*
-* U'*(A, B)*W = (A11 A12) (B11 B12) n1
+* U**H*(A, B)*W = (A11 A12) (B11 B12) n1
* ( 0 A22),( 0 B22) n2
* n1 n2 n1 n2
*
-* where N = n1+n2 and U' means the conjugate transpose of U. The first
+* where N = n1+n2 and U**H means the conjugate 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).
*
* If (A, B) has been obtained from the generalized real Schur
-* decomposition of a matrix pair (C, D) = Q*(A, B)*Z', then the
+* decomposition of a matrix pair (C, D) = Q*(A, B)*Z**H, then the
* reordered generalized Schur form of (C, D) is given by
*
-* (C, D) = (Q*U)*(U'*(A, B)*W)*(Z*W)',
+* (C, D) = (Q*U)*(U**H *(A, B)*W)*(Z*W)**H,
*
* and the first n1 columns of Q*U and Z*W span the corresponding
* deflating subspaces of (C, D) (Q and Z store Q*U and Z*W, resp.).
*
* On exit,
*
-* U'*A*Q = D1*( 0 R ), V'*B*Q = D2*( 0 R ),
+* U**H *A*Q = D1*( 0 R ), V**H *B*Q = D2*( 0 R ),
*
-* where U, V and Q are unitary matrices, Z' denotes the conjugate
-* transpose of Z, R is a nonsingular upper triangular matrix, and D1
+* where U, V and Q are unitary matrices.
+* R is a nonsingular upper triangular matrix, and D1
* and D2 are ``diagonal'' matrices, which are of the following
* structures:
*
* ALPHA(K+1:M)= C, ALPHA(M+1:K+L)= 0
* BETA(K+1:M) = S, BETA(M+1:K+L) = 1.
* Furthermore, if K+L < N,
-* ALPHA(K+L+1:N) = 0
+* ALPHA(K+L+1:N) = 0 and
* BETA(K+L+1:N) = 0.
*
* U (input/output) COMPLEX*16 array, dimension (LDU,M)
* min(L,M-K)-by-L triangular (or trapezoidal) matrix A23 and L-by-L
* matrix B13 to the form:
*
-* U1'*A13*Q1 = C1*R1; V1'*B13*Q1 = S1*R1,
+* U1**H *A13*Q1 = C1*R1; V1**H *B13*Q1 = S1*R1,
*
-* where U1, V1 and Q1 are unitary matrix, and Z' is the conjugate
-* transpose of Z. C1 and S1 are diagonal matrices satisfying
+* where U1, V1 and Q1 are unitary matrix.
+* C1 and S1 are diagonal matrices satisfying
*
* C1**2 + S1**2 = I,
*
CALL ZLAGS2( UPPER, A1, A2, A3, B1, B2, B3, CSU, SNU,
$ CSV, SNV, CSQ, SNQ )
*
-* Update (K+I)-th and (K+J)-th rows of matrix A: U'*A
+* Update (K+I)-th and (K+J)-th rows of matrix A: U**H *A
*
IF( K+J.LE.M )
$ CALL ZROT( L, A( K+J, N-L+1 ), LDA, A( K+I, N-L+1 ),
$ LDA, CSU, DCONJG( SNU ) )
*
-* Update I-th and J-th rows of matrix B: V'*B
+* Update I-th and J-th rows of matrix B: V**H *B
*
CALL ZROT( L, B( J, N-L+1 ), LDB, B( I, N-L+1 ), LDB,
$ CSV, DCONJG( SNV ) )
END IF
*
ELSE
+*
ALPHA( K+I ) = ZERO
BETA( K+I ) = ONE
CALL ZCOPY( L-I+1, B( I, N-L+I ), LDB, A( K+I, N-L+I ),
* The reciprocal of the condition number of the i-th generalized
* eigenvalue w = (a, b) is defined as
*
-* S(I) = (|v'Au|**2 + |v'Bu|**2)**(1/2) / (norm(u)*norm(v))
+* S(I) = (|v**HAu|**2 + |v**HBu|**2)**(1/2) / (norm(u)*norm(v))
*
* where u and v are the right and left eigenvectors of (A, B)
* corresponding to w; |z| denotes the absolute value of the complex
* number, and norm(u) denotes the 2-norm of the vector u. The pair
-* (a, b) corresponds to an eigenvalue w = a/b (= v'Au/v'Bu) of the
+* (a, b) corresponds to an eigenvalue w = a/b (= v**HAu/v**HBu) of the
* matrix pair (A, B). If both a and b equal zero, then (A,B) is
* singular and S(I) = -1 is returned.
*
* Zl = [ kron(a, In-1) -kron(1, A22) ]
* [ kron(b, In-1) -kron(1, B22) ].
*
-* Here In-1 is the identity matrix of size n-1 and X' is the conjugate
+* Here In-1 is the identity matrix of size n-1 and X**H is the conjugate
* transpose of X. kron(X, Y) is the Kronecker product between the
* matrices X and Y.
*
ELSE
*
* Solve transposed (I, J) - system:
-* A(I, I)' * R(I, J) + D(I, I)' * L(J, J) = C(I, J)
+* A(I, I)**H * R(I, J) + D(I, I)**H * L(J, J) = C(I, J)
* R(I, I) * B(J, J) + L(I, J) * E(J, J) = -F(I, J)
* for I = 1, 2, ..., M, J = N, N - 1, ..., 1
*
* 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 (TRANS = 'C') is used to compute an one-norm-based estimate
* of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D)
ELSE
*
* Solve transposed (I, J)-subsystem
-* A(I, I)' * R(I, J) + D(I, I)' * L(I, J) = C(I, J)
+* A(I, I)**H * R(I, J) + D(I, I)**H * L(I, J) = C(I, J)
* R(I, J) * B(J, J) + L(I, J) * E(J, J) = -F(I, J)
* for I = 1,2,..., P; J = Q, Q-1,..., 1
*
90 CONTINUE
*
* Solve the triangular system:
-* (T(KI+1:N,KI+1:N) - T(KI,KI))'*X = SCALE*WORK.
+* (T(KI+1:N,KI+1:N) - T(KI,KI))**H * X = SCALE*WORK.
*
DO 100 K = KI + 1, N
T( K, K ) = T( K, K ) - T( KI, KI )
* transformation Z to move them to the top left corner of T. In other
* words, the selected eigenvalues are the eigenvalues of T11 in:
*
-* Z'*T*Z = ( T11 T12 ) n1
+* Z**H * T * Z = ( T11 T12 ) n1
* ( 0 T22 ) n2
* n1 n2
*
-* where N = n1+n2 and Z' means the conjugate transpose of Z. The first
+* where N = n1+n2. The first
* n1 columns of Z span the specified invariant subspace of T.
*
* If T has been obtained from the Schur factorization of a matrix
-* A = Q*T*Q', then the reordered Schur factorization of A is given by
-* A = (Q*Z)*(Z'*T*Z)*(Q*Z)', and the first n1 columns of Q*Z span the
+* A = Q*T*Q**H, then the reordered Schur factorization of A is given by
+* A = (Q*Z)*(Z**H*T*Z)*(Q*Z)**H, and the first n1 columns of Q*Z span the
* corresponding invariant subspace of A.
*
* The reciprocal condition number of the average of the eigenvalues of
$ IERR )
ELSE
*
-* Solve T11'*R - R*T22' = scale*X.
+* Solve T11**H*R - R*T22**H = scale*X.
*
CALL ZTRSYL( 'C', 'C', -1, N1, N2, T, LDT,
$ T( N1+1, N1+1 ), LDT, WORK, N1, SCALE,
* The reciprocal of the condition number of an eigenvalue lambda is
* defined as
*
-* S(lambda) = |v'*u| / (norm(u)*norm(v))
+* S(lambda) = |v**H*u| / (norm(u)*norm(v))
*
* where u and v are the right and left eigenvectors of T corresponding
-* to lambda; v' denotes the conjugate transpose of v, and norm(u)
+* to lambda; v**H denotes the conjugate transpose of v, and norm(u)
* denotes the Euclidean norm. These reciprocal condition numbers always
* lie between zero (very badly conditioned) and one (very well
* conditioned). If n = 1, S(lambda) is defined to be 1.
WORK( I, I ) = WORK( I, I ) - WORK( 1, 1 )
20 CONTINUE
*
-* Estimate a lower bound for the 1-norm of inv(C'). The 1st
+* Estimate a lower bound for the 1-norm of inv(C**H). The 1st
* and (N+1)th columns of WORK are used to store work vectors.
*
SEP( KS ) = ZERO
IF( KASE.NE.0 ) THEN
IF( KASE.EQ.1 ) THEN
*
-* Solve C'*x = scale*b
+* Solve C**H*x = scale*b
*
CALL ZLATRS( 'Upper', 'Conjugate transpose',
$ 'Nonunit', NORMIN, N-1, WORK( 2, 2 ),
*
ELSE IF( .NOT.NOTRNA .AND. NOTRNB ) THEN
*
-* Solve A' *X + ISGN*X*B = scale*C.
+* Solve A**H *X + ISGN*X*B = scale*C.
*
* The (K,L)th block of X is determined starting from
* upper-left corner column by column by
*
-* A'(K,K)*X(K,L) + ISGN*X(K,L)*B(L,L) = C(K,L) - R(K,L)
+* A**H(K,K)*X(K,L) + ISGN*X(K,L)*B(L,L) = C(K,L) - R(K,L)
*
* Where
-* K-1 L-1
-* R(K,L) = SUM [A'(I,K)*X(I,L)] + ISGN*SUM [X(K,J)*B(J,L)]
-* I=1 J=1
+* K-1 L-1
+* R(K,L) = SUM [A**H(I,K)*X(I,L)] + ISGN*SUM [X(K,J)*B(J,L)]
+* I=1 J=1
*
DO 60 L = 1, N
DO 50 K = 1, M
*
ELSE IF( .NOT.NOTRNA .AND. .NOT.NOTRNB ) THEN
*
-* Solve A'*X + ISGN*X*B' = C.
+* Solve A**H*X + ISGN*X*B**H = C.
*
* The (K,L)th block of X is determined starting from
* upper-right corner column by column by
*
-* A'(K,K)*X(K,L) + ISGN*X(K,L)*B'(L,L) = C(K,L) - R(K,L)
+* A**H(K,K)*X(K,L) + ISGN*X(K,L)*B**H(L,L) = C(K,L) - R(K,L)
*
* Where
* K-1
-* R(K,L) = SUM [A'(I,K)*X(I,L)] +
+* R(K,L) = SUM [A**H(I,K)*X(I,L)] +
* I=1
* N
-* ISGN*SUM [X(K,J)*B'(L,J)].
+* ISGN*SUM [X(K,J)*B**H(L,J)].
* J=L+1
*
DO 90 L = N, 1, -1
*
ELSE IF( NOTRNA .AND. .NOT.NOTRNB ) THEN
*
-* Solve A*X + ISGN*X*B' = C.
+* Solve A*X + ISGN*X*B**H = C.
*
* The (K,L)th block of X is determined starting from
* bottom-left corner column by column by
*
-* A(K,K)*X(K,L) + ISGN*X(K,L)*B'(L,L) = C(K,L) - R(K,L)
+* A(K,K)*X(K,L) + ISGN*X(K,L)*B**H(L,L) = C(K,L) - R(K,L)
*
* Where
* M N
-* R(K,L) = SUM [A(K,I)*X(I,L)] + ISGN*SUM [X(K,J)*B'(L,J)]
+* R(K,L) = SUM [A(K,I)*X(I,L)] + ISGN*SUM [X(K,J)*B**H(L,J)]
* I=K+1 J=L+1
*
DO 120 L = N, 1, -1
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
-* ( 0 )
-* ( z( k ) )
+* T( k ) = I - tau*u( k )*u( k )**H, u( k ) = ( 1 ),
+* ( 0 )
+* ( z( k ) )
*
* tau is a scalar and z( k ) is an ( n - m ) element vector.
* tau and z( k ) are chosen to annihilate the elements of the kth row
*
IF( TAU( K ).NE.CZERO .AND. K.GT.1 ) THEN
*
-* We now perform the operation A := A*P( k )'.
+* We now perform the operation A := A*P( k )**H.
*
* Use the first ( k - 1 ) elements of TAU to store a( k ),
* where a( k ) consists of the first ( k - 1 ) elements of
$ LDA, A( K, M1 ), LDA, CONE, TAU, 1 )
*
* Now form a( k ) := a( k ) - conjg(tau)*w
-* and B := B - conjg(tau)*w*z( k )'.
+* and B := B - conjg(tau)*w*z( k )**H.
*
CALL ZAXPY( K-1, -DCONJG( TAU( K ) ), TAU, 1, A( 1, K ),
$ 1 )
*
* where
*
-* T( k ) = I - tau*u( k )*u( k )', u( k ) = ( 1 ),
+* T( k ) = I - tau*u( k )*u( k )**H, u( k ) = ( 1 ),
* ( 0 )
* ( z( k ) )
*
* which is defined as the first m rows of a product of k elementary
* reflectors of order n
*
-* Q = H(k)' . . . H(2)' H(1)'
+* Q = H(k)**H . . . H(2)**H H(1)**H
*
* as returned by ZGELQF.
*
*
DO 40 I = K, 1, -1
*
-* Apply H(i)' to A(i:m,i:n) from the right
+* Apply H(i)**H to A(i:m,i:n) from the right
*
IF( I.LT.N ) THEN
CALL ZLACGV( N-I, A( I, I+1 ), LDA )
* which is defined as the first M rows of a product of K elementary
* reflectors of order N
*
-* Q = H(k)' . . . H(2)' H(1)'
+* Q = H(k)**H . . . H(2)**H H(1)**H
*
* as returned by ZGELQF.
*
CALL ZLARFT( 'Forward', 'Rowwise', N-I+1, IB, A( I, I ),
$ LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(i+ib:m,i:n) from the right
+* Apply H**H to A(i+ib:m,i:n) from the right
*
CALL ZLARFB( 'Right', 'Conjugate transpose', 'Forward',
$ 'Rowwise', M-I-IB+1, N-I+1, IB, A( I, I ),
$ WORK( IB+1 ), LDWORK )
END IF
*
-* Apply H' to columns i:n of current block
+* Apply H**H to columns i:n of current block
*
CALL ZUNGL2( IB, N-I+1, IB, A( I, I ), LDA, TAU( I ), WORK,
$ IINFO )
* which is defined as the last m rows of a product of k elementary
* reflectors of order n
*
-* Q = H(1)' H(2)' . . . H(k)'
+* Q = H(1)**H H(2)**H . . . H(k)**H
*
* as returned by ZGERQF.
*
DO 40 I = 1, K
II = M - K + I
*
-* Apply H(i)' to A(1:m-k+i,1:n-k+i) from the right
+* Apply H(i)**H to A(1:m-k+i,1:n-k+i) from the right
*
CALL ZLACGV( N-M+II-1, A( II, 1 ), LDA )
A( II, N-M+II ) = ONE
* which is defined as the last M rows of a product of K elementary
* reflectors of order N
*
-* Q = H(1)' H(2)' . . . H(k)'
+* Q = H(1)**H H(2)**H . . . H(k)**H
*
* as returned by ZGERQF.
*
CALL ZLARFT( 'Backward', 'Rowwise', N-K+I+IB-1, IB,
$ A( II, 1 ), LDA, TAU( I ), WORK, LDWORK )
*
-* Apply H' to A(1:m-k+i-1,1:n-k+i+ib-1) from the right
+* Apply H**H to A(1:m-k+i-1,1:n-k+i+ib-1) from the right
*
CALL ZLARFB( 'Right', 'Conjugate transpose', 'Backward',
$ 'Rowwise', II-1, N-K+I+IB-1, IB, A( II, 1 ),
$ LDWORK )
END IF
*
-* Apply H' to columns 1:n-k+i+ib-1 of current block
+* Apply H**H to columns 1:n-k+i+ib-1 of current block
*
CALL ZUNGR2( IB, N-K+I+IB-1, IB, A( II, 1 ), LDA, TAU( I ),
$ WORK, IINFO )
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'C', or
+* Q**H* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'C',
+* C * Q**H if SIDE = 'R' and TRANS = 'C',
*
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**H from the Left
+* = 'R': apply Q or Q**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'C': apply Q' (Conjugate transpose)
+* = 'C': apply Q**H (Conjugate transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) COMPLEX*16 array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(1:m-k+i,1:n)
+* H(i) or H(i)**H is applied to C(1:m-k+i,1:n)
*
MI = M - K + I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,1:n-k+i)
+* H(i) or H(i)**H is applied to C(1:m,1:n-k+i)
*
NI = N - K + I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = TAU( I )
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'C', or
+* Q**H* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'C',
+* C * Q**H if SIDE = 'R' and TRANS = 'C',
*
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**H from the Left
+* = 'R': apply Q or Q**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'C': apply Q' (Conjugate transpose)
+* = 'C': apply Q**H (Conjugate transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) COMPLEX*16 array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(i:m,1:n)
+* H(i) or H(i)**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,i:n)
+* H(i) or H(i)**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = TAU( I )
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'C', or
+* Q**H* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'C',
+* C * Q**H if SIDE = 'R' and TRANS = 'C',
*
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
*
-* Q = H(k)' . . . H(2)' H(1)'
+* Q = H(k)**H . . . H(2)**H H(1)**H
*
* as returned by ZGELQF. Q is of order m if SIDE = 'L' and of order n
* if SIDE = 'R'.
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**H from the Left
+* = 'R': apply Q or Q**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'C': apply Q' (Conjugate transpose)
+* = 'C': apply Q**H (Conjugate transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) COMPLEX*16 array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(i:m,1:n)
+* H(i) or H(i)**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,i:n)
+* H(i) or H(i)**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = DCONJG( TAU( I ) )
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
*
-* Q = H(k)' . . . H(2)' H(1)'
+* Q = H(k)**H . . . H(2)**H H(1)**H
*
* as returned by ZGELQF. Q is of order M if SIDE = 'L' and of order N
* if SIDE = 'R'.
$ LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**H
*
CALL ZLARFB( SIDE, TRANST, 'Forward', 'Rowwise', MI, NI, IB,
$ A( I, I ), LDA, T, LDT, C( IC, JC ), LDC, WORK,
$ A( 1, I ), LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(1:m-k+i+ib-1,1:n)
+* H or H**H is applied to C(1:m-k+i+ib-1,1:n)
*
MI = M - K + I + IB - 1
ELSE
*
-* H or H' is applied to C(1:m,1:n-k+i+ib-1)
+* H or H**H is applied to C(1:m,1:n-k+i+ib-1)
*
NI = N - K + I + IB - 1
END IF
*
-* Apply H or H'
+* Apply H or H**H
*
CALL ZLARFB( SIDE, TRANS, 'Backward', 'Columnwise', MI, NI,
$ IB, A( 1, I ), LDA, T, LDT, C, LDC, WORK,
$ LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**H
*
CALL ZLARFB( SIDE, TRANS, 'Forward', 'Columnwise', MI, NI,
$ IB, A( I, I ), LDA, T, LDT, C( IC, JC ), LDC,
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'C', or
+* Q**H* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'C',
+* C * Q**H if SIDE = 'R' and TRANS = 'C',
*
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
*
-* Q = H(1)' H(2)' . . . H(k)'
+* Q = H(1)**H H(2)**H . . . H(k)**H
*
* as returned by ZGERQF. Q is of order m if SIDE = 'L' and of order n
* if SIDE = 'R'.
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**H from the Left
+* = 'R': apply Q or Q**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'C': apply Q' (Conjugate transpose)
+* = 'C': apply Q**H (Conjugate transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) COMPLEX*16 array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(1:m-k+i,1:n)
+* H(i) or H(i)**H is applied to C(1:m-k+i,1:n)
*
MI = M - K + I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,1:n-k+i)
+* H(i) or H(i)**H is applied to C(1:m,1:n-k+i)
*
NI = N - K + I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = DCONJG( TAU( I ) )
*
* Q * C if SIDE = 'L' and TRANS = 'N', or
*
-* Q'* C if SIDE = 'L' and TRANS = 'C', or
+* Q**H* C if SIDE = 'L' and TRANS = 'C', or
*
* C * Q if SIDE = 'R' and TRANS = 'N', or
*
-* C * Q' if SIDE = 'R' and TRANS = 'C',
+* C * Q**H if SIDE = 'R' and TRANS = 'C',
*
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
* =========
*
* SIDE (input) CHARACTER*1
-* = 'L': apply Q or Q' from the Left
-* = 'R': apply Q or Q' from the Right
+* = 'L': apply Q or Q**H from the Left
+* = 'R': apply Q or Q**H from the Right
*
* TRANS (input) CHARACTER*1
* = 'N': apply Q (No transpose)
-* = 'C': apply Q' (Conjugate transpose)
+* = 'C': apply Q**H (Conjugate transpose)
*
* M (input) INTEGER
* The number of rows of the matrix C. M >= 0.
*
* C (input/output) COMPLEX*16 array, dimension (LDC,N)
* On entry, the m-by-n matrix C.
-* On exit, C is overwritten by Q*C or Q'*C or C*Q' or C*Q.
+* On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*
* LDC (input) INTEGER
* The leading dimension of the array C. LDC >= max(1,M).
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(i:m,1:n)
+* H(i) or H(i)**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,i:n)
+* H(i) or H(i)**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = TAU( I )
* where Q is a complex unitary matrix defined as the product of k
* elementary reflectors
*
-* Q = H(1)' H(2)' . . . H(k)'
+* Q = H(1)**H H(2)**H . . . H(k)**H
*
* as returned by ZGERQF. Q is of order M if SIDE = 'L' and of order N
* if SIDE = 'R'.
$ A( I, 1 ), LDA, TAU( I ), T, LDT )
IF( LEFT ) THEN
*
-* H or H' is applied to C(1:m-k+i+ib-1,1:n)
+* H or H**H is applied to C(1:m-k+i+ib-1,1:n)
*
MI = M - K + I + IB - 1
ELSE
*
-* H or H' is applied to C(1:m,1:n-k+i+ib-1)
+* H or H**H is applied to C(1:m,1:n-k+i+ib-1)
*
NI = N - K + I + IB - 1
END IF
*
-* Apply H or H'
+* Apply H or H**H
*
CALL ZLARFB( SIDE, TRANST, 'Backward', 'Rowwise', MI, NI,
$ IB, A( I, 1 ), LDA, T, LDT, C, LDC, WORK,
*
IF( LEFT ) THEN
*
-* H or H' is applied to C(i:m,1:n)
+* H or H**H is applied to C(i:m,1:n)
*
MI = M - I + 1
IC = I
ELSE
*
-* H or H' is applied to C(1:m,i:n)
+* H or H**H is applied to C(1:m,i:n)
*
NI = N - I + 1
JC = I
END IF
*
-* Apply H or H'
+* Apply H or H**H
*
CALL ZLARZB( SIDE, TRANST, 'Backward', 'Rowwise', MI, NI,
$ IB, L, A( I, JA ), LDA, T, LDT, C( IC, JC ),
DO 10 I = I1, I2, I3
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(1:i,1:n)
+* H(i) or H(i)**H is applied to C(1:i,1:n)
*
MI = I
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,1:i)
+* H(i) or H(i)**H is applied to C(1:m,1:i)
*
NI = I
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = TAU( I )
AP( II ) = ONE
IF( LEFT ) THEN
*
-* H(i) or H(i)' is applied to C(i+1:m,1:n)
+* H(i) or H(i)**H is applied to C(i+1:m,1:n)
*
MI = M - I
IC = I + 1
ELSE
*
-* H(i) or H(i)' is applied to C(1:m,i+1:n)
+* H(i) or H(i)**H is applied to C(1:m,i+1:n)
*
NI = N - I
JC = I + 1
END IF
*
-* Apply H(i) or H(i)'
+* Apply H(i) or H(i)**H
*
IF( NOTRAN ) THEN
TAUI = TAU( I )
projects / platform / upstream / lapack.git / commitdiff