LAPACK  3.6.0 LAPACK: Linear Algebra PACKage
complex
Collaboration diagram for complex:


This browser is not able to show SVG: try Firefox, Chrome, Safari, or Opera instead.

## Functions

subroutine cgesc2 (N, A, LDA, RHS, IPIV, JPIV, SCALE)
CGESC2 solves a system of linear equations using the LU factorization with complete pivoting computed by sgetc2. More...

subroutine cgetc2 (N, A, LDA, IPIV, JPIV, INFO)
CGETC2 computes the LU factorization with complete pivoting of the general n-by-n matrix. More...

real function clange (NORM, M, N, A, LDA, WORK)
CLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a general rectangular matrix. More...

subroutine claqge (M, N, A, LDA, R, C, ROWCND, COLCND, AMAX, EQUED)
CLAQGE scales a general rectangular matrix, using row and column scaling factors computed by sgeequ. More...

subroutine ctgex2 (WANTQ, WANTZ, N, A, LDA, B, LDB, Q, LDQ, Z, LDZ, J1, INFO)
CTGEX2 swaps adjacent diagonal blocks in an upper (quasi) triangular matrix pair by an unitary equivalence transformation. More...

## Detailed Description

This is the group of complex auxiliary functions for GE matrices

## Function Documentation

 subroutine cgesc2 ( integer N, complex, dimension( lda, * ) A, integer LDA, complex, dimension( * ) RHS, integer, dimension( * ) IPIV, integer, dimension( * ) JPIV, real SCALE )

CGESC2 solves a system of linear equations using the LU factorization with complete pivoting computed by sgetc2.

Purpose:
``` CGESC2 solves a system of linear equations

A * X = scale* RHS

with a general N-by-N matrix A using the LU factorization with
complete pivoting computed by CGETC2.```
Parameters
 [in] N ``` N is INTEGER The number of columns of the matrix A.``` [in] A ``` A is COMPLEX array, dimension (LDA, N) On entry, the LU part of the factorization of the n-by-n matrix A computed by CGETC2: A = P * L * U * Q``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(1, N).``` [in,out] RHS ``` RHS is COMPLEX array, dimension N. On entry, the right hand side vector b. On exit, the solution vector X.``` [in] IPIV ``` IPIV is INTEGER array, dimension (N). The pivot indices; for 1 <= i <= N, row i of the matrix has been interchanged with row IPIV(i).``` [in] JPIV ``` JPIV is INTEGER array, dimension (N). The pivot indices; for 1 <= j <= N, column j of the matrix has been interchanged with column JPIV(j).``` [out] SCALE ``` SCALE is REAL On exit, SCALE contains the scale factor. SCALE is chosen 0 <= SCALE <= 1 to prevent owerflow in the solution.```
Date
September 2012
Contributors:
Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901 87 Umea, Sweden.

Definition at line 117 of file cgesc2.f.

117 *
118 * -- LAPACK auxiliary routine (version 3.4.2) --
119 * -- LAPACK is a software package provided by Univ. of Tennessee, --
120 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
121 * September 2012
122 *
123 * .. Scalar Arguments ..
124  INTEGER lda, n
125  REAL scale
126 * ..
127 * .. Array Arguments ..
128  INTEGER ipiv( * ), jpiv( * )
129  COMPLEX a( lda, * ), rhs( * )
130 * ..
131 *
132 * =====================================================================
133 *
134 * .. Parameters ..
135  REAL zero, one, two
136  parameter( zero = 0.0e+0, one = 1.0e+0, two = 2.0e+0 )
137 * ..
138 * .. Local Scalars ..
139  INTEGER i, j
140  REAL bignum, eps, smlnum
141  COMPLEX temp
142 * ..
143 * .. External Subroutines ..
145 * ..
146 * .. External Functions ..
147  INTEGER icamax
148  REAL slamch
149  EXTERNAL icamax, slamch
150 * ..
151 * .. Intrinsic Functions ..
152  INTRINSIC abs, cmplx, real
153 * ..
154 * .. Executable Statements ..
155 *
156 * Set constant to control overflow
157 *
158  eps = slamch( 'P' )
159  smlnum = slamch( 'S' ) / eps
160  bignum = one / smlnum
161  CALL slabad( smlnum, bignum )
162 *
163 * Apply permutations IPIV to RHS
164 *
165  CALL claswp( 1, rhs, lda, 1, n-1, ipiv, 1 )
166 *
167 * Solve for L part
168 *
169  DO 20 i = 1, n - 1
170  DO 10 j = i + 1, n
171  rhs( j ) = rhs( j ) - a( j, i )*rhs( i )
172  10 CONTINUE
173  20 CONTINUE
174 *
175 * Solve for U part
176 *
177  scale = one
178 *
179 * Check for scaling
180 *
181  i = icamax( n, rhs, 1 )
182  IF( two*smlnum*abs( rhs( i ) ).GT.abs( a( n, n ) ) ) THEN
183  temp = cmplx( one / two, zero ) / abs( rhs( i ) )
184  CALL cscal( n, temp, rhs( 1 ), 1 )
185  scale = scale*REAL( temp )
186  END IF
187  DO 40 i = n, 1, -1
188  temp = cmplx( one, zero ) / a( i, i )
189  rhs( i ) = rhs( i )*temp
190  DO 30 j = i + 1, n
191  rhs( i ) = rhs( i ) - rhs( j )*( a( i, j )*temp )
192  30 CONTINUE
193  40 CONTINUE
194 *
195 * Apply permutations JPIV to the solution (RHS)
196 *
197  CALL claswp( 1, rhs, lda, 1, n-1, jpiv, -1 )
198  RETURN
199 *
200 * End of CGESC2
201 *
subroutine claswp(N, A, LDA, K1, K2, IPIV, INCX)
CLASWP performs a series of row interchanges on a general rectangular matrix.
Definition: claswp.f:116
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:69
integer function icamax(N, CX, INCX)
ICAMAX
Definition: icamax.f:53
subroutine cscal(N, CA, CX, INCX)
CSCAL
Definition: cscal.f:54

Here is the call graph for this function:

Here is the caller graph for this function:

 subroutine cgetc2 ( integer N, complex, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, integer, dimension( * ) JPIV, integer INFO )

CGETC2 computes the LU factorization with complete pivoting of the general n-by-n matrix.

Purpose:
``` CGETC2 computes an LU factorization, using complete pivoting, of the
n-by-n matrix A. The factorization has the form A = P * L * U * Q,
where P and Q are permutation matrices, L is lower triangular with
unit diagonal elements and U is upper triangular.

This is a level 1 BLAS version of the algorithm.```
Parameters
 [in] N ``` N is INTEGER The order of the matrix A. N >= 0.``` [in,out] A ``` A is COMPLEX array, dimension (LDA, N) On entry, the n-by-n matrix to be factored. On exit, the factors L and U from the factorization A = P*L*U*Q; the unit diagonal elements of L are not stored. If U(k, k) appears to be less than SMIN, U(k, k) is given the value of SMIN, giving a nonsingular perturbed system.``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(1, N).``` [out] IPIV ``` IPIV is INTEGER array, dimension (N). The pivot indices; for 1 <= i <= N, row i of the matrix has been interchanged with row IPIV(i).``` [out] JPIV ``` JPIV is INTEGER array, dimension (N). The pivot indices; for 1 <= j <= N, column j of the matrix has been interchanged with column JPIV(j).``` [out] INFO ``` INFO is INTEGER = 0: successful exit > 0: if INFO = k, U(k, k) is likely to produce overflow if one tries to solve for x in Ax = b. So U is perturbed to avoid the overflow.```
Date
November 2013
Contributors:
Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901 87 Umea, Sweden.

Definition at line 113 of file cgetc2.f.

113 *
114 * -- LAPACK auxiliary routine (version 3.5.0) --
115 * -- LAPACK is a software package provided by Univ. of Tennessee, --
116 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
117 * November 2013
118 *
119 * .. Scalar Arguments ..
120  INTEGER info, lda, n
121 * ..
122 * .. Array Arguments ..
123  INTEGER ipiv( * ), jpiv( * )
124  COMPLEX a( lda, * )
125 * ..
126 *
127 * =====================================================================
128 *
129 * .. Parameters ..
130  REAL zero, one
131  parameter( zero = 0.0e+0, one = 1.0e+0 )
132 * ..
133 * .. Local Scalars ..
134  INTEGER i, ip, ipv, j, jp, jpv
135  REAL bignum, eps, smin, smlnum, xmax
136 * ..
137 * .. External Subroutines ..
139 * ..
140 * .. External Functions ..
141  REAL slamch
142  EXTERNAL slamch
143 * ..
144 * .. Intrinsic Functions ..
145  INTRINSIC abs, cmplx, max
146 * ..
147 * .. Executable Statements ..
148 *
149 * Set constants to control overflow
150 *
151  info = 0
152  eps = slamch( 'P' )
153  smlnum = slamch( 'S' ) / eps
154  bignum = one / smlnum
155  CALL slabad( smlnum, bignum )
156 *
157 * Factorize A using complete pivoting.
158 * Set pivots less than SMIN to SMIN
159 *
160  DO 40 i = 1, n - 1
161 *
162 * Find max element in matrix A
163 *
164  xmax = zero
165  DO 20 ip = i, n
166  DO 10 jp = i, n
167  IF( abs( a( ip, jp ) ).GE.xmax ) THEN
168  xmax = abs( a( ip, jp ) )
169  ipv = ip
170  jpv = jp
171  END IF
172  10 CONTINUE
173  20 CONTINUE
174  IF( i.EQ.1 )
175  \$ smin = max( eps*xmax, smlnum )
176 *
177 * Swap rows
178 *
179  IF( ipv.NE.i )
180  \$ CALL cswap( n, a( ipv, 1 ), lda, a( i, 1 ), lda )
181  ipiv( i ) = ipv
182 *
183 * Swap columns
184 *
185  IF( jpv.NE.i )
186  \$ CALL cswap( n, a( 1, jpv ), 1, a( 1, i ), 1 )
187  jpiv( i ) = jpv
188 *
189 * Check for singularity
190 *
191  IF( abs( a( i, i ) ).LT.smin ) THEN
192  info = i
193  a( i, i ) = cmplx( smin, zero )
194  END IF
195  DO 30 j = i + 1, n
196  a( j, i ) = a( j, i ) / a( i, i )
197  30 CONTINUE
198  CALL cgeru( n-i, n-i, -cmplx( one ), a( i+1, i ), 1,
199  \$ a( i, i+1 ), lda, a( i+1, i+1 ), lda )
200  40 CONTINUE
201 *
202  IF( abs( a( n, n ) ).LT.smin ) THEN
203  info = n
204  a( n, n ) = cmplx( smin, zero )
205  END IF
206 *
207 * Set last pivots to N
208 *
209  ipiv( n ) = n
210  jpiv( n ) = n
211 *
212  RETURN
213 *
214 * End of CGETC2
215 *
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:69
subroutine cgeru(M, N, ALPHA, X, INCX, Y, INCY, A, LDA)
CGERU
Definition: cgeru.f:132
subroutine cswap(N, CX, INCX, CY, INCY)
CSWAP
Definition: cswap.f:52

Here is the call graph for this function:

Here is the caller graph for this function:

 real function clange ( character NORM, integer M, integer N, complex, dimension( lda, * ) A, integer LDA, real, dimension( * ) WORK )

CLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a general rectangular matrix.

Purpose:
``` CLANGE  returns the value of the one norm,  or the Frobenius norm, or
the  infinity norm,  or the  element of  largest absolute value  of a
complex matrix A.```
Returns
CLANGE
```    CLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm'
(
( norm1(A),         NORM = '1', 'O' or 'o'
(
( normI(A),         NORM = 'I' or 'i'
(
( normF(A),         NORM = 'F', 'f', 'E' or 'e'

where  norm1  denotes the  one norm of a matrix (maximum column sum),
normI  denotes the  infinity norm  of a matrix  (maximum row sum) and
normF  denotes the  Frobenius norm of a matrix (square root of sum of
squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm.```
Parameters
 [in] NORM ``` NORM is CHARACTER*1 Specifies the value to be returned in CLANGE as described above.``` [in] M ``` M is INTEGER The number of rows of the matrix A. M >= 0. When M = 0, CLANGE is set to zero.``` [in] N ``` N is INTEGER The number of columns of the matrix A. N >= 0. When N = 0, CLANGE is set to zero.``` [in] A ``` A is COMPLEX array, dimension (LDA,N) The m by n matrix A.``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(M,1).``` [out] WORK ``` WORK is REAL array, dimension (MAX(1,LWORK)), where LWORK >= M when NORM = 'I'; otherwise, WORK is not referenced.```
Date
September 2012

Definition at line 117 of file clange.f.

117 *
118 * -- LAPACK auxiliary routine (version 3.4.2) --
119 * -- LAPACK is a software package provided by Univ. of Tennessee, --
120 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
121 * September 2012
122 *
123 * .. Scalar Arguments ..
124  CHARACTER norm
125  INTEGER lda, m, n
126 * ..
127 * .. Array Arguments ..
128  REAL work( * )
129  COMPLEX a( lda, * )
130 * ..
131 *
132 * =====================================================================
133 *
134 * .. Parameters ..
135  REAL one, zero
136  parameter( one = 1.0e+0, zero = 0.0e+0 )
137 * ..
138 * .. Local Scalars ..
139  INTEGER i, j
140  REAL scale, sum, VALUE, temp
141 * ..
142 * .. External Functions ..
143  LOGICAL lsame, sisnan
144  EXTERNAL lsame, sisnan
145 * ..
146 * .. External Subroutines ..
147  EXTERNAL classq
148 * ..
149 * .. Intrinsic Functions ..
150  INTRINSIC abs, min, sqrt
151 * ..
152 * .. Executable Statements ..
153 *
154  IF( min( m, n ).EQ.0 ) THEN
155  VALUE = zero
156  ELSE IF( lsame( norm, 'M' ) ) THEN
157 *
158 * Find max(abs(A(i,j))).
159 *
160  VALUE = zero
161  DO 20 j = 1, n
162  DO 10 i = 1, m
163  temp = abs( a( i, j ) )
164  IF( VALUE.LT.temp .OR. sisnan( temp ) ) VALUE = temp
165  10 CONTINUE
166  20 CONTINUE
167  ELSE IF( ( lsame( norm, 'O' ) ) .OR. ( norm.EQ.'1' ) ) THEN
168 *
169 * Find norm1(A).
170 *
171  VALUE = zero
172  DO 40 j = 1, n
173  sum = zero
174  DO 30 i = 1, m
175  sum = sum + abs( a( i, j ) )
176  30 CONTINUE
177  IF( VALUE.LT.sum .OR. sisnan( sum ) ) VALUE = sum
178  40 CONTINUE
179  ELSE IF( lsame( norm, 'I' ) ) THEN
180 *
181 * Find normI(A).
182 *
183  DO 50 i = 1, m
184  work( i ) = zero
185  50 CONTINUE
186  DO 70 j = 1, n
187  DO 60 i = 1, m
188  work( i ) = work( i ) + abs( a( i, j ) )
189  60 CONTINUE
190  70 CONTINUE
191  VALUE = zero
192  DO 80 i = 1, m
193  temp = work( i )
194  IF( VALUE.LT.temp .OR. sisnan( temp ) ) VALUE = temp
195  80 CONTINUE
196  ELSE IF( ( lsame( norm, 'F' ) ) .OR. ( lsame( norm, 'E' ) ) ) THEN
197 *
198 * Find normF(A).
199 *
200  scale = zero
201  sum = one
202  DO 90 j = 1, n
203  CALL classq( m, a( 1, j ), 1, scale, sum )
204  90 CONTINUE
205  VALUE = scale*sqrt( sum )
206  END IF
207 *
208  clange = VALUE
209  RETURN
210 *
211 * End of CLANGE
212 *
logical function sisnan(SIN)
SISNAN tests input for NaN.
Definition: sisnan.f:61
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
subroutine classq(N, X, INCX, SCALE, SUMSQ)
CLASSQ updates a sum of squares represented in scaled form.
Definition: classq.f:108
real function clange(NORM, M, N, A, LDA, WORK)
CLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition: clange.f:117

Here is the call graph for this function:

Here is the caller graph for this function:

 subroutine claqge ( integer M, integer N, complex, dimension( lda, * ) A, integer LDA, real, dimension( * ) R, real, dimension( * ) C, real ROWCND, real COLCND, real AMAX, character EQUED )

CLAQGE scales a general rectangular matrix, using row and column scaling factors computed by sgeequ.

Purpose:
``` CLAQGE equilibrates a general M by N matrix A using the row and
column scaling factors in the vectors R and C.```
Parameters
 [in] M ``` M is INTEGER The number of rows of the matrix A. M >= 0.``` [in] N ``` N is INTEGER The number of columns of the matrix A. N >= 0.``` [in,out] A ``` A is COMPLEX array, dimension (LDA,N) On entry, the M by N matrix A. On exit, the equilibrated matrix. See EQUED for the form of the equilibrated matrix.``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(M,1).``` [in] R ``` R is REAL array, dimension (M) The row scale factors for A.``` [in] C ``` C is REAL array, dimension (N) The column scale factors for A.``` [in] ROWCND ``` ROWCND is REAL Ratio of the smallest R(i) to the largest R(i).``` [in] COLCND ``` COLCND is REAL Ratio of the smallest C(i) to the largest C(i).``` [in] AMAX ``` AMAX is REAL Absolute value of largest matrix entry.``` [out] EQUED ``` EQUED is CHARACTER*1 Specifies the form of equilibration that was done. = 'N': No equilibration = 'R': Row equilibration, i.e., A has been premultiplied by diag(R). = 'C': Column equilibration, i.e., A has been postmultiplied by diag(C). = 'B': Both row and column equilibration, i.e., A has been replaced by diag(R) * A * diag(C).```
Internal Parameters:
```  THRESH is a threshold value used to decide if row or column scaling
should be done based on the ratio of the row or column scaling
factors.  If ROWCND < THRESH, row scaling is done, and if
COLCND < THRESH, column scaling is done.

LARGE and SMALL are threshold values used to decide if row scaling
should be done based on the absolute size of the largest matrix
element.  If AMAX > LARGE or AMAX < SMALL, row scaling is done.```
Date
September 2012

Definition at line 145 of file claqge.f.

145 *
146 * -- LAPACK auxiliary routine (version 3.4.2) --
147 * -- LAPACK is a software package provided by Univ. of Tennessee, --
148 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
149 * September 2012
150 *
151 * .. Scalar Arguments ..
152  CHARACTER equed
153  INTEGER lda, m, n
154  REAL amax, colcnd, rowcnd
155 * ..
156 * .. Array Arguments ..
157  REAL c( * ), r( * )
158  COMPLEX a( lda, * )
159 * ..
160 *
161 * =====================================================================
162 *
163 * .. Parameters ..
164  REAL one, thresh
165  parameter( one = 1.0e+0, thresh = 0.1e+0 )
166 * ..
167 * .. Local Scalars ..
168  INTEGER i, j
169  REAL cj, large, small
170 * ..
171 * .. External Functions ..
172  REAL slamch
173  EXTERNAL slamch
174 * ..
175 * .. Executable Statements ..
176 *
177 * Quick return if possible
178 *
179  IF( m.LE.0 .OR. n.LE.0 ) THEN
180  equed = 'N'
181  RETURN
182  END IF
183 *
184 * Initialize LARGE and SMALL.
185 *
186  small = slamch( 'Safe minimum' ) / slamch( 'Precision' )
187  large = one / small
188 *
189  IF( rowcnd.GE.thresh .AND. amax.GE.small .AND. amax.LE.large )
190  \$ THEN
191 *
192 * No row scaling
193 *
194  IF( colcnd.GE.thresh ) THEN
195 *
196 * No column scaling
197 *
198  equed = 'N'
199  ELSE
200 *
201 * Column scaling
202 *
203  DO 20 j = 1, n
204  cj = c( j )
205  DO 10 i = 1, m
206  a( i, j ) = cj*a( i, j )
207  10 CONTINUE
208  20 CONTINUE
209  equed = 'C'
210  END IF
211  ELSE IF( colcnd.GE.thresh ) THEN
212 *
213 * Row scaling, no column scaling
214 *
215  DO 40 j = 1, n
216  DO 30 i = 1, m
217  a( i, j ) = r( i )*a( i, j )
218  30 CONTINUE
219  40 CONTINUE
220  equed = 'R'
221  ELSE
222 *
223 * Row and column scaling
224 *
225  DO 60 j = 1, n
226  cj = c( j )
227  DO 50 i = 1, m
228  a( i, j ) = cj*r( i )*a( i, j )
229  50 CONTINUE
230  60 CONTINUE
231  equed = 'B'
232  END IF
233 *
234  RETURN
235 *
236 * End of CLAQGE
237 *
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:69

Here is the caller graph for this function:

 subroutine ctgex2 ( logical WANTQ, logical WANTZ, integer N, complex, dimension( lda, * ) A, integer LDA, complex, dimension( ldb, * ) B, integer LDB, complex, dimension( ldq, * ) Q, integer LDQ, complex, dimension( ldz, * ) Z, integer LDZ, integer J1, integer INFO )

CTGEX2 swaps adjacent diagonal blocks in an upper (quasi) triangular matrix pair by an unitary equivalence transformation.

Purpose:
``` CTGEX2 swaps adjacent diagonal 1 by 1 blocks (A11,B11) and (A22,B22)
in an upper triangular matrix pair (A, B) by an unitary equivalence
transformation.

(A, B) must be in generalized Schur canonical form, that is, A and
B are both upper triangular.

Optionally, the matrices Q and Z of generalized Schur vectors are
updated.

Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H
Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H```
Parameters
 [in] WANTQ ``` WANTQ is LOGICAL .TRUE. : update the left transformation matrix Q; .FALSE.: do not update Q.``` [in] WANTZ ``` WANTZ is LOGICAL .TRUE. : update the right transformation matrix Z; .FALSE.: do not update Z.``` [in] N ``` N is INTEGER The order of the matrices A and B. N >= 0.``` [in,out] A ``` A is COMPLEX arrays, dimensions (LDA,N) On entry, the matrix A in the pair (A, B). On exit, the updated matrix A.``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).``` [in,out] B ``` B is COMPLEX arrays, dimensions (LDB,N) On entry, the matrix B in the pair (A, B). On exit, the updated matrix B.``` [in] LDB ``` LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).``` [in,out] Q ``` Q is COMPLEX array, dimension (LDZ,N) If WANTQ = .TRUE, on entry, the unitary matrix Q. On exit, the updated matrix Q. Not referenced if WANTQ = .FALSE..``` [in] LDQ ``` LDQ is INTEGER The leading dimension of the array Q. LDQ >= 1; If WANTQ = .TRUE., LDQ >= N.``` [in,out] Z ``` Z is COMPLEX array, dimension (LDZ,N) If WANTZ = .TRUE, on entry, the unitary matrix Z. On exit, the updated matrix Z. Not referenced if WANTZ = .FALSE..``` [in] LDZ ``` LDZ is INTEGER The leading dimension of the array Z. LDZ >= 1; If WANTZ = .TRUE., LDZ >= N.``` [in] J1 ``` J1 is INTEGER The index to the first block (A11, B11).``` [out] INFO ``` INFO is INTEGER =0: Successful exit. =1: The transformed matrix pair (A, B) would be too far from generalized Schur form; the problem is ill- conditioned.```
Date
September 2012
Further Details:
In the current code both weak and strong stability tests are performed. The user can omit the strong stability test by changing the internal logical parameter WANDS to .FALSE.. See ref. [2] for details.
Contributors:
Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901 87 Umea, Sweden.
References:
[1] B. Kagstrom; A Direct Method for Reordering Eigenvalues in the Generalized Real Schur Form of a Regular Matrix Pair (A, B), in M.S. Moonen et al (eds), Linear Algebra for Large Scale and Real-Time Applications, Kluwer Academic Publ. 1993, pp 195-218.
[2] B. Kagstrom and P. Poromaa; Computing Eigenspaces with Specified Eigenvalues of a Regular Matrix Pair (A, B) and Condition Estimation: Theory, Algorithms and Software, Report UMINF-94.04, Department of Computing Science, Umea University, S-901 87 Umea, Sweden, 1994. Also as LAPACK Working Note 87. To appear in Numerical Algorithms, 1996.

Definition at line 192 of file ctgex2.f.

192 *
193 * -- LAPACK auxiliary routine (version 3.4.2) --
194 * -- LAPACK is a software package provided by Univ. of Tennessee, --
195 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
196 * September 2012
197 *
198 * .. Scalar Arguments ..
199  LOGICAL wantq, wantz
200  INTEGER info, j1, lda, ldb, ldq, ldz, n
201 * ..
202 * .. Array Arguments ..
203  COMPLEX a( lda, * ), b( ldb, * ), q( ldq, * ),
204  \$ z( ldz, * )
205 * ..
206 *
207 * =====================================================================
208 *
209 * .. Parameters ..
210  COMPLEX czero, cone
211  parameter( czero = ( 0.0e+0, 0.0e+0 ),
212  \$ cone = ( 1.0e+0, 0.0e+0 ) )
213  REAL twenty
214  parameter( twenty = 2.0e+1 )
215  INTEGER ldst
216  parameter( ldst = 2 )
217  LOGICAL wands
218  parameter( wands = .true. )
219 * ..
220 * .. Local Scalars ..
221  LOGICAL strong, weak
222  INTEGER i, m
223  REAL cq, cz, eps, sa, sb, scale, smlnum, ss, sum,
224  \$ thresh, ws
225  COMPLEX cdum, f, g, sq, sz
226 * ..
227 * .. Local Arrays ..
228  COMPLEX s( ldst, ldst ), t( ldst, ldst ), work( 8 )
229 * ..
230 * .. External Functions ..
231  REAL slamch
232  EXTERNAL slamch
233 * ..
234 * .. External Subroutines ..
235  EXTERNAL clacpy, clartg, classq, crot
236 * ..
237 * .. Intrinsic Functions ..
238  INTRINSIC abs, conjg, max, REAL, sqrt
239 * ..
240 * .. Executable Statements ..
241 *
242  info = 0
243 *
244 * Quick return if possible
245 *
246  IF( n.LE.1 )
247  \$ RETURN
248 *
249  m = ldst
250  weak = .false.
251  strong = .false.
252 *
253 * Make a local copy of selected block in (A, B)
254 *
255  CALL clacpy( 'Full', m, m, a( j1, j1 ), lda, s, ldst )
256  CALL clacpy( 'Full', m, m, b( j1, j1 ), ldb, t, ldst )
257 *
258 * Compute the threshold for testing the acceptance of swapping.
259 *
260  eps = slamch( 'P' )
261  smlnum = slamch( 'S' ) / eps
262  scale = REAL( czero )
263  sum = REAL( cone )
264  CALL clacpy( 'Full', m, m, s, ldst, work, m )
265  CALL clacpy( 'Full', m, m, t, ldst, work( m*m+1 ), m )
266  CALL classq( 2*m*m, work, 1, scale, sum )
267  sa = scale*sqrt( sum )
268 *
269 * THRES has been changed from
270 * THRESH = MAX( TEN*EPS*SA, SMLNUM )
271 * to
272 * THRESH = MAX( TWENTY*EPS*SA, SMLNUM )
273 * on 04/01/10.
274 * "Bug" reported by Ondra Kamenik, confirmed by Julie Langou, fixed by
275 * Jim Demmel and Guillaume Revy. See forum post 1783.
276 *
277  thresh = max( twenty*eps*sa, smlnum )
278 *
279 * Compute unitary QL and RQ that swap 1-by-1 and 1-by-1 blocks
280 * using Givens rotations and perform the swap tentatively.
281 *
282  f = s( 2, 2 )*t( 1, 1 ) - t( 2, 2 )*s( 1, 1 )
283  g = s( 2, 2 )*t( 1, 2 ) - t( 2, 2 )*s( 1, 2 )
284  sa = abs( s( 2, 2 ) )
285  sb = abs( t( 2, 2 ) )
286  CALL clartg( g, f, cz, sz, cdum )
287  sz = -sz
288  CALL crot( 2, s( 1, 1 ), 1, s( 1, 2 ), 1, cz, conjg( sz ) )
289  CALL crot( 2, t( 1, 1 ), 1, t( 1, 2 ), 1, cz, conjg( sz ) )
290  IF( sa.GE.sb ) THEN
291  CALL clartg( s( 1, 1 ), s( 2, 1 ), cq, sq, cdum )
292  ELSE
293  CALL clartg( t( 1, 1 ), t( 2, 1 ), cq, sq, cdum )
294  END IF
295  CALL crot( 2, s( 1, 1 ), ldst, s( 2, 1 ), ldst, cq, sq )
296  CALL crot( 2, t( 1, 1 ), ldst, t( 2, 1 ), ldst, cq, sq )
297 *
298 * Weak stability test: |S21| + |T21| <= O(EPS F-norm((S, T)))
299 *
300  ws = abs( s( 2, 1 ) ) + abs( t( 2, 1 ) )
301  weak = ws.LE.thresh
302  IF( .NOT.weak )
303  \$ GO TO 20
304 *
305  IF( wands ) THEN
306 *
307 * Strong stability test:
308 * F-norm((A-QL**H*S*QR, B-QL**H*T*QR)) <= O(EPS*F-norm((A, B)))
309 *
310  CALL clacpy( 'Full', m, m, s, ldst, work, m )
311  CALL clacpy( 'Full', m, m, t, ldst, work( m*m+1 ), m )
312  CALL crot( 2, work, 1, work( 3 ), 1, cz, -conjg( sz ) )
313  CALL crot( 2, work( 5 ), 1, work( 7 ), 1, cz, -conjg( sz ) )
314  CALL crot( 2, work, 2, work( 2 ), 2, cq, -sq )
315  CALL crot( 2, work( 5 ), 2, work( 6 ), 2, cq, -sq )
316  DO 10 i = 1, 2
317  work( i ) = work( i ) - a( j1+i-1, j1 )
318  work( i+2 ) = work( i+2 ) - a( j1+i-1, j1+1 )
319  work( i+4 ) = work( i+4 ) - b( j1+i-1, j1 )
320  work( i+6 ) = work( i+6 ) - b( j1+i-1, j1+1 )
321  10 CONTINUE
322  scale = REAL( czero )
323  sum = REAL( cone )
324  CALL classq( 2*m*m, work, 1, scale, sum )
325  ss = scale*sqrt( sum )
326  strong = ss.LE.thresh
327  IF( .NOT.strong )
328  \$ GO TO 20
329  END IF
330 *
331 * If the swap is accepted ("weakly" and "strongly"), apply the
332 * equivalence transformations to the original matrix pair (A,B)
333 *
334  CALL crot( j1+1, a( 1, j1 ), 1, a( 1, j1+1 ), 1, cz, conjg( sz ) )
335  CALL crot( j1+1, b( 1, j1 ), 1, b( 1, j1+1 ), 1, cz, conjg( sz ) )
336  CALL crot( n-j1+1, a( j1, j1 ), lda, a( j1+1, j1 ), lda, cq, sq )
337  CALL crot( n-j1+1, b( j1, j1 ), ldb, b( j1+1, j1 ), ldb, cq, sq )
338 *
339 * Set N1 by N2 (2,1) blocks to 0
340 *
341  a( j1+1, j1 ) = czero
342  b( j1+1, j1 ) = czero
343 *
344 * Accumulate transformations into Q and Z if requested.
345 *
346  IF( wantz )
347  \$ CALL crot( n, z( 1, j1 ), 1, z( 1, j1+1 ), 1, cz, conjg( sz ) )
348  IF( wantq )
349  \$ CALL crot( n, q( 1, j1 ), 1, q( 1, j1+1 ), 1, cq, conjg( sq ) )
350 *
351 * Exit with INFO = 0 if swap was successfully performed.
352 *
353  RETURN
354 *
355 * Exit with INFO = 1 if swap was rejected.
356 *
357  20 CONTINUE
358  info = 1
359  RETURN
360 *
361 * End of CTGEX2
362 *
subroutine crot(N, CX, INCX, CY, INCY, C, S)
CROT applies a plane rotation with real cosine and complex sine to a pair of complex vectors...
Definition: crot.f:105
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:69
subroutine clartg(F, G, CS, SN, R)
CLARTG generates a plane rotation with real cosine and complex sine.
Definition: clartg.f:105
subroutine clacpy(UPLO, M, N, A, LDA, B, LDB)
CLACPY copies all or part of one two-dimensional array to another.
Definition: clacpy.f:105
subroutine classq(N, X, INCX, SCALE, SUMSQ)
CLASSQ updates a sum of squares represented in scaled form.
Definition: classq.f:108

Here is the call graph for this function:

Here is the caller graph for this function: