LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
cggev.f
Go to the documentation of this file.
00001 *> \brief <b> CGGEV computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices</b>
00002 *
00003 *  =========== DOCUMENTATION ===========
00004 *
00005 * Online html documentation available at 
00006 *            http://www.netlib.org/lapack/explore-html/ 
00007 *
00008 *> \htmlonly
00009 *> Download CGGEV + dependencies 
00010 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/cggev.f"> 
00011 *> [TGZ]</a> 
00012 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/cggev.f"> 
00013 *> [ZIP]</a> 
00014 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/cggev.f"> 
00015 *> [TXT]</a>
00016 *> \endhtmlonly 
00017 *
00018 *  Definition:
00019 *  ===========
00020 *
00021 *       SUBROUTINE CGGEV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHA, BETA,
00022 *                         VL, LDVL, VR, LDVR, WORK, LWORK, RWORK, INFO )
00023 * 
00024 *       .. Scalar Arguments ..
00025 *       CHARACTER          JOBVL, JOBVR
00026 *       INTEGER            INFO, LDA, LDB, LDVL, LDVR, LWORK, N
00027 *       ..
00028 *       .. Array Arguments ..
00029 *       REAL               RWORK( * )
00030 *       COMPLEX            A( LDA, * ), ALPHA( * ), B( LDB, * ),
00031 *      $                   BETA( * ), VL( LDVL, * ), VR( LDVR, * ),
00032 *      $                   WORK( * )
00033 *       ..
00034 *  
00035 *
00036 *> \par Purpose:
00037 *  =============
00038 *>
00039 *> \verbatim
00040 *>
00041 *> CGGEV computes for a pair of N-by-N complex nonsymmetric matrices
00042 *> (A,B), the generalized eigenvalues, and optionally, the left and/or
00043 *> right generalized eigenvectors.
00044 *>
00045 *> A generalized eigenvalue for a pair of matrices (A,B) is a scalar
00046 *> lambda or a ratio alpha/beta = lambda, such that A - lambda*B is
00047 *> singular. It is usually represented as the pair (alpha,beta), as
00048 *> there is a reasonable interpretation for beta=0, and even for both
00049 *> being zero.
00050 *>
00051 *> The right generalized eigenvector v(j) corresponding to the
00052 *> generalized eigenvalue lambda(j) of (A,B) satisfies
00053 *>
00054 *>              A * v(j) = lambda(j) * B * v(j).
00055 *>
00056 *> The left generalized eigenvector u(j) corresponding to the
00057 *> generalized eigenvalues lambda(j) of (A,B) satisfies
00058 *>
00059 *>              u(j)**H * A = lambda(j) * u(j)**H * B
00060 *>
00061 *> where u(j)**H is the conjugate-transpose of u(j).
00062 *> \endverbatim
00063 *
00064 *  Arguments:
00065 *  ==========
00066 *
00067 *> \param[in] JOBVL
00068 *> \verbatim
00069 *>          JOBVL is CHARACTER*1
00070 *>          = 'N':  do not compute the left generalized eigenvectors;
00071 *>          = 'V':  compute the left generalized eigenvectors.
00072 *> \endverbatim
00073 *>
00074 *> \param[in] JOBVR
00075 *> \verbatim
00076 *>          JOBVR is CHARACTER*1
00077 *>          = 'N':  do not compute the right generalized eigenvectors;
00078 *>          = 'V':  compute the right generalized eigenvectors.
00079 *> \endverbatim
00080 *>
00081 *> \param[in] N
00082 *> \verbatim
00083 *>          N is INTEGER
00084 *>          The order of the matrices A, B, VL, and VR.  N >= 0.
00085 *> \endverbatim
00086 *>
00087 *> \param[in,out] A
00088 *> \verbatim
00089 *>          A is COMPLEX array, dimension (LDA, N)
00090 *>          On entry, the matrix A in the pair (A,B).
00091 *>          On exit, A has been overwritten.
00092 *> \endverbatim
00093 *>
00094 *> \param[in] LDA
00095 *> \verbatim
00096 *>          LDA is INTEGER
00097 *>          The leading dimension of A.  LDA >= max(1,N).
00098 *> \endverbatim
00099 *>
00100 *> \param[in,out] B
00101 *> \verbatim
00102 *>          B is COMPLEX array, dimension (LDB, N)
00103 *>          On entry, the matrix B in the pair (A,B).
00104 *>          On exit, B has been overwritten.
00105 *> \endverbatim
00106 *>
00107 *> \param[in] LDB
00108 *> \verbatim
00109 *>          LDB is INTEGER
00110 *>          The leading dimension of B.  LDB >= max(1,N).
00111 *> \endverbatim
00112 *>
00113 *> \param[out] ALPHA
00114 *> \verbatim
00115 *>          ALPHA is COMPLEX array, dimension (N)
00116 *> \endverbatim
00117 *>
00118 *> \param[out] BETA
00119 *> \verbatim
00120 *>          BETA is COMPLEX array, dimension (N)
00121 *>          On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the
00122 *>          generalized eigenvalues.
00123 *>
00124 *>          Note: the quotients ALPHA(j)/BETA(j) may easily over- or
00125 *>          underflow, and BETA(j) may even be zero.  Thus, the user
00126 *>          should avoid naively computing the ratio alpha/beta.
00127 *>          However, ALPHA will be always less than and usually
00128 *>          comparable with norm(A) in magnitude, and BETA always less
00129 *>          than and usually comparable with norm(B).
00130 *> \endverbatim
00131 *>
00132 *> \param[out] VL
00133 *> \verbatim
00134 *>          VL is COMPLEX array, dimension (LDVL,N)
00135 *>          If JOBVL = 'V', the left generalized eigenvectors u(j) are
00136 *>          stored one after another in the columns of VL, in the same
00137 *>          order as their eigenvalues.
00138 *>          Each eigenvector is scaled so the largest component has
00139 *>          abs(real part) + abs(imag. part) = 1.
00140 *>          Not referenced if JOBVL = 'N'.
00141 *> \endverbatim
00142 *>
00143 *> \param[in] LDVL
00144 *> \verbatim
00145 *>          LDVL is INTEGER
00146 *>          The leading dimension of the matrix VL. LDVL >= 1, and
00147 *>          if JOBVL = 'V', LDVL >= N.
00148 *> \endverbatim
00149 *>
00150 *> \param[out] VR
00151 *> \verbatim
00152 *>          VR is COMPLEX array, dimension (LDVR,N)
00153 *>          If JOBVR = 'V', the right generalized eigenvectors v(j) are
00154 *>          stored one after another in the columns of VR, in the same
00155 *>          order as their eigenvalues.
00156 *>          Each eigenvector is scaled so the largest component has
00157 *>          abs(real part) + abs(imag. part) = 1.
00158 *>          Not referenced if JOBVR = 'N'.
00159 *> \endverbatim
00160 *>
00161 *> \param[in] LDVR
00162 *> \verbatim
00163 *>          LDVR is INTEGER
00164 *>          The leading dimension of the matrix VR. LDVR >= 1, and
00165 *>          if JOBVR = 'V', LDVR >= N.
00166 *> \endverbatim
00167 *>
00168 *> \param[out] WORK
00169 *> \verbatim
00170 *>          WORK is COMPLEX array, dimension (MAX(1,LWORK))
00171 *>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
00172 *> \endverbatim
00173 *>
00174 *> \param[in] LWORK
00175 *> \verbatim
00176 *>          LWORK is INTEGER
00177 *>          The dimension of the array WORK.  LWORK >= max(1,2*N).
00178 *>          For good performance, LWORK must generally be larger.
00179 *>
00180 *>          If LWORK = -1, then a workspace query is assumed; the routine
00181 *>          only calculates the optimal size of the WORK array, returns
00182 *>          this value as the first entry of the WORK array, and no error
00183 *>          message related to LWORK is issued by XERBLA.
00184 *> \endverbatim
00185 *>
00186 *> \param[out] RWORK
00187 *> \verbatim
00188 *>          RWORK is REAL array, dimension (8*N)
00189 *> \endverbatim
00190 *>
00191 *> \param[out] INFO
00192 *> \verbatim
00193 *>          INFO is INTEGER
00194 *>          = 0:  successful exit
00195 *>          < 0:  if INFO = -i, the i-th argument had an illegal value.
00196 *>          =1,...,N:
00197 *>                The QZ iteration failed.  No eigenvectors have been
00198 *>                calculated, but ALPHA(j) and BETA(j) should be
00199 *>                correct for j=INFO+1,...,N.
00200 *>          > N:  =N+1: other then QZ iteration failed in SHGEQZ,
00201 *>                =N+2: error return from STGEVC.
00202 *> \endverbatim
00203 *
00204 *  Authors:
00205 *  ========
00206 *
00207 *> \author Univ. of Tennessee 
00208 *> \author Univ. of California Berkeley 
00209 *> \author Univ. of Colorado Denver 
00210 *> \author NAG Ltd. 
00211 *
00212 *> \date April 2012
00213 *
00214 *> \ingroup complexGEeigen
00215 *
00216 *  =====================================================================
00217       SUBROUTINE CGGEV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHA, BETA,
00218      $                  VL, LDVL, VR, LDVR, WORK, LWORK, RWORK, INFO )
00219 *
00220 *  -- LAPACK driver routine (version 3.4.1) --
00221 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
00222 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
00223 *     April 2012
00224 *
00225 *     .. Scalar Arguments ..
00226       CHARACTER          JOBVL, JOBVR
00227       INTEGER            INFO, LDA, LDB, LDVL, LDVR, LWORK, N
00228 *     ..
00229 *     .. Array Arguments ..
00230       REAL               RWORK( * )
00231       COMPLEX            A( LDA, * ), ALPHA( * ), B( LDB, * ),
00232      $                   BETA( * ), VL( LDVL, * ), VR( LDVR, * ),
00233      $                   WORK( * )
00234 *     ..
00235 *
00236 *  =====================================================================
00237 *
00238 *     .. Parameters ..
00239       REAL               ZERO, ONE
00240       PARAMETER          ( ZERO = 0.0E0, ONE = 1.0E0 )
00241       COMPLEX            CZERO, CONE
00242       PARAMETER          ( CZERO = ( 0.0E0, 0.0E0 ),
00243      $                   CONE = ( 1.0E0, 0.0E0 ) )
00244 *     ..
00245 *     .. Local Scalars ..
00246       LOGICAL            ILASCL, ILBSCL, ILV, ILVL, ILVR, LQUERY
00247       CHARACTER          CHTEMP
00248       INTEGER            ICOLS, IERR, IHI, IJOBVL, IJOBVR, ILEFT, ILO,
00249      $                   IN, IRIGHT, IROWS, IRWRK, ITAU, IWRK, JC, JR,
00250      $                   LWKMIN, LWKOPT
00251       REAL               ANRM, ANRMTO, BIGNUM, BNRM, BNRMTO, EPS,
00252      $                   SMLNUM, TEMP
00253       COMPLEX            X
00254 *     ..
00255 *     .. Local Arrays ..
00256       LOGICAL            LDUMMA( 1 )
00257 *     ..
00258 *     .. External Subroutines ..
00259       EXTERNAL           CGEQRF, CGGBAK, CGGBAL, CGGHRD, CHGEQZ, CLACPY,
00260      $                   CLASCL, CLASET, CTGEVC, CUNGQR, CUNMQR, SLABAD,
00261      $                   XERBLA
00262 *     ..
00263 *     .. External Functions ..
00264       LOGICAL            LSAME
00265       INTEGER            ILAENV
00266       REAL               CLANGE, SLAMCH
00267       EXTERNAL           LSAME, ILAENV, CLANGE, SLAMCH
00268 *     ..
00269 *     .. Intrinsic Functions ..
00270       INTRINSIC          ABS, AIMAG, MAX, REAL, SQRT
00271 *     ..
00272 *     .. Statement Functions ..
00273       REAL               ABS1
00274 *     ..
00275 *     .. Statement Function definitions ..
00276       ABS1( X ) = ABS( REAL( X ) ) + ABS( AIMAG( X ) )
00277 *     ..
00278 *     .. Executable Statements ..
00279 *
00280 *     Decode the input arguments
00281 *
00282       IF( LSAME( JOBVL, 'N' ) ) THEN
00283          IJOBVL = 1
00284          ILVL = .FALSE.
00285       ELSE IF( LSAME( JOBVL, 'V' ) ) THEN
00286          IJOBVL = 2
00287          ILVL = .TRUE.
00288       ELSE
00289          IJOBVL = -1
00290          ILVL = .FALSE.
00291       END IF
00292 *
00293       IF( LSAME( JOBVR, 'N' ) ) THEN
00294          IJOBVR = 1
00295          ILVR = .FALSE.
00296       ELSE IF( LSAME( JOBVR, 'V' ) ) THEN
00297          IJOBVR = 2
00298          ILVR = .TRUE.
00299       ELSE
00300          IJOBVR = -1
00301          ILVR = .FALSE.
00302       END IF
00303       ILV = ILVL .OR. ILVR
00304 *
00305 *     Test the input arguments
00306 *
00307       INFO = 0
00308       LQUERY = ( LWORK.EQ.-1 )
00309       IF( IJOBVL.LE.0 ) THEN
00310          INFO = -1
00311       ELSE IF( IJOBVR.LE.0 ) THEN
00312          INFO = -2
00313       ELSE IF( N.LT.0 ) THEN
00314          INFO = -3
00315       ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
00316          INFO = -5
00317       ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
00318          INFO = -7
00319       ELSE IF( LDVL.LT.1 .OR. ( ILVL .AND. LDVL.LT.N ) ) THEN
00320          INFO = -11
00321       ELSE IF( LDVR.LT.1 .OR. ( ILVR .AND. LDVR.LT.N ) ) THEN
00322          INFO = -13
00323       END IF
00324 *
00325 *     Compute workspace
00326 *      (Note: Comments in the code beginning "Workspace:" describe the
00327 *       minimal amount of workspace needed at that point in the code,
00328 *       as well as the preferred amount for good performance.
00329 *       NB refers to the optimal block size for the immediately
00330 *       following subroutine, as returned by ILAENV. The workspace is
00331 *       computed assuming ILO = 1 and IHI = N, the worst case.)
00332 *
00333       IF( INFO.EQ.0 ) THEN
00334          LWKMIN = MAX( 1, 2*N )
00335          LWKOPT = MAX( 1, N + N*ILAENV( 1, 'CGEQRF', ' ', N, 1, N, 0 ) )
00336          LWKOPT = MAX( LWKOPT, N +
00337      $                 N*ILAENV( 1, 'CUNMQR', ' ', N, 1, N, 0 ) ) 
00338          IF( ILVL ) THEN
00339             LWKOPT = MAX( LWKOPT, N +
00340      $                 N*ILAENV( 1, 'CUNGQR', ' ', N, 1, N, -1 ) )
00341          END IF
00342          WORK( 1 ) = LWKOPT
00343 *
00344          IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY )
00345      $      INFO = -15
00346       END IF
00347 *
00348       IF( INFO.NE.0 ) THEN
00349          CALL XERBLA( 'CGGEV ', -INFO )
00350          RETURN
00351       ELSE IF( LQUERY ) THEN
00352          RETURN
00353       END IF
00354 *
00355 *     Quick return if possible
00356 *
00357       IF( N.EQ.0 )
00358      $   RETURN
00359 *
00360 *     Get machine constants
00361 *
00362       EPS = SLAMCH( 'E' )*SLAMCH( 'B' )
00363       SMLNUM = SLAMCH( 'S' )
00364       BIGNUM = ONE / SMLNUM
00365       CALL SLABAD( SMLNUM, BIGNUM )
00366       SMLNUM = SQRT( SMLNUM ) / EPS
00367       BIGNUM = ONE / SMLNUM
00368 *
00369 *     Scale A if max element outside range [SMLNUM,BIGNUM]
00370 *
00371       ANRM = CLANGE( 'M', N, N, A, LDA, RWORK )
00372       ILASCL = .FALSE.
00373       IF( ANRM.GT.ZERO .AND. ANRM.LT.SMLNUM ) THEN
00374          ANRMTO = SMLNUM
00375          ILASCL = .TRUE.
00376       ELSE IF( ANRM.GT.BIGNUM ) THEN
00377          ANRMTO = BIGNUM
00378          ILASCL = .TRUE.
00379       END IF
00380       IF( ILASCL )
00381      $   CALL CLASCL( 'G', 0, 0, ANRM, ANRMTO, N, N, A, LDA, IERR )
00382 *
00383 *     Scale B if max element outside range [SMLNUM,BIGNUM]
00384 *
00385       BNRM = CLANGE( 'M', N, N, B, LDB, RWORK )
00386       ILBSCL = .FALSE.
00387       IF( BNRM.GT.ZERO .AND. BNRM.LT.SMLNUM ) THEN
00388          BNRMTO = SMLNUM
00389          ILBSCL = .TRUE.
00390       ELSE IF( BNRM.GT.BIGNUM ) THEN
00391          BNRMTO = BIGNUM
00392          ILBSCL = .TRUE.
00393       END IF
00394       IF( ILBSCL )
00395      $   CALL CLASCL( 'G', 0, 0, BNRM, BNRMTO, N, N, B, LDB, IERR )
00396 *
00397 *     Permute the matrices A, B to isolate eigenvalues if possible
00398 *     (Real Workspace: need 6*N)
00399 *
00400       ILEFT = 1
00401       IRIGHT = N + 1
00402       IRWRK = IRIGHT + N
00403       CALL CGGBAL( 'P', N, A, LDA, B, LDB, ILO, IHI, RWORK( ILEFT ),
00404      $             RWORK( IRIGHT ), RWORK( IRWRK ), IERR )
00405 *
00406 *     Reduce B to triangular form (QR decomposition of B)
00407 *     (Complex Workspace: need N, prefer N*NB)
00408 *
00409       IROWS = IHI + 1 - ILO
00410       IF( ILV ) THEN
00411          ICOLS = N + 1 - ILO
00412       ELSE
00413          ICOLS = IROWS
00414       END IF
00415       ITAU = 1
00416       IWRK = ITAU + IROWS
00417       CALL CGEQRF( IROWS, ICOLS, B( ILO, ILO ), LDB, WORK( ITAU ),
00418      $             WORK( IWRK ), LWORK+1-IWRK, IERR )
00419 *
00420 *     Apply the orthogonal transformation to matrix A
00421 *     (Complex Workspace: need N, prefer N*NB)
00422 *
00423       CALL CUNMQR( 'L', 'C', IROWS, ICOLS, IROWS, B( ILO, ILO ), LDB,
00424      $             WORK( ITAU ), A( ILO, ILO ), LDA, WORK( IWRK ),
00425      $             LWORK+1-IWRK, IERR )
00426 *
00427 *     Initialize VL
00428 *     (Complex Workspace: need N, prefer N*NB)
00429 *
00430       IF( ILVL ) THEN
00431          CALL CLASET( 'Full', N, N, CZERO, CONE, VL, LDVL )
00432          IF( IROWS.GT.1 ) THEN
00433             CALL CLACPY( 'L', IROWS-1, IROWS-1, B( ILO+1, ILO ), LDB,
00434      $                   VL( ILO+1, ILO ), LDVL )
00435          END IF
00436          CALL CUNGQR( IROWS, IROWS, IROWS, VL( ILO, ILO ), LDVL,
00437      $                WORK( ITAU ), WORK( IWRK ), LWORK+1-IWRK, IERR )
00438       END IF
00439 *
00440 *     Initialize VR
00441 *
00442       IF( ILVR )
00443      $   CALL CLASET( 'Full', N, N, CZERO, CONE, VR, LDVR )
00444 *
00445 *     Reduce to generalized Hessenberg form
00446 *
00447       IF( ILV ) THEN
00448 *
00449 *        Eigenvectors requested -- work on whole matrix.
00450 *
00451          CALL CGGHRD( JOBVL, JOBVR, N, ILO, IHI, A, LDA, B, LDB, VL,
00452      $                LDVL, VR, LDVR, IERR )
00453       ELSE
00454          CALL CGGHRD( 'N', 'N', IROWS, 1, IROWS, A( ILO, ILO ), LDA,
00455      $                B( ILO, ILO ), LDB, VL, LDVL, VR, LDVR, IERR )
00456       END IF
00457 *
00458 *     Perform QZ algorithm (Compute eigenvalues, and optionally, the
00459 *     Schur form and Schur vectors)
00460 *     (Complex Workspace: need N)
00461 *     (Real Workspace: need N)
00462 *
00463       IWRK = ITAU
00464       IF( ILV ) THEN
00465          CHTEMP = 'S'
00466       ELSE
00467          CHTEMP = 'E'
00468       END IF
00469       CALL CHGEQZ( CHTEMP, JOBVL, JOBVR, N, ILO, IHI, A, LDA, B, LDB,
00470      $             ALPHA, BETA, VL, LDVL, VR, LDVR, WORK( IWRK ),
00471      $             LWORK+1-IWRK, RWORK( IRWRK ), IERR )
00472       IF( IERR.NE.0 ) THEN
00473          IF( IERR.GT.0 .AND. IERR.LE.N ) THEN
00474             INFO = IERR
00475          ELSE IF( IERR.GT.N .AND. IERR.LE.2*N ) THEN
00476             INFO = IERR - N
00477          ELSE
00478             INFO = N + 1
00479          END IF
00480          GO TO 70
00481       END IF
00482 *
00483 *     Compute Eigenvectors
00484 *     (Real Workspace: need 2*N)
00485 *     (Complex Workspace: need 2*N)
00486 *
00487       IF( ILV ) THEN
00488          IF( ILVL ) THEN
00489             IF( ILVR ) THEN
00490                CHTEMP = 'B'
00491             ELSE
00492                CHTEMP = 'L'
00493             END IF
00494          ELSE
00495             CHTEMP = 'R'
00496          END IF
00497 *
00498          CALL CTGEVC( CHTEMP, 'B', LDUMMA, N, A, LDA, B, LDB, VL, LDVL,
00499      $                VR, LDVR, N, IN, WORK( IWRK ), RWORK( IRWRK ),
00500      $                IERR )
00501          IF( IERR.NE.0 ) THEN
00502             INFO = N + 2
00503             GO TO 70
00504          END IF
00505 *
00506 *        Undo balancing on VL and VR and normalization
00507 *        (Workspace: none needed)
00508 *
00509          IF( ILVL ) THEN
00510             CALL CGGBAK( 'P', 'L', N, ILO, IHI, RWORK( ILEFT ),
00511      $                   RWORK( IRIGHT ), N, VL, LDVL, IERR )
00512             DO 30 JC = 1, N
00513                TEMP = ZERO
00514                DO 10 JR = 1, N
00515                   TEMP = MAX( TEMP, ABS1( VL( JR, JC ) ) )
00516    10          CONTINUE
00517                IF( TEMP.LT.SMLNUM )
00518      $            GO TO 30
00519                TEMP = ONE / TEMP
00520                DO 20 JR = 1, N
00521                   VL( JR, JC ) = VL( JR, JC )*TEMP
00522    20          CONTINUE
00523    30       CONTINUE
00524          END IF
00525          IF( ILVR ) THEN
00526             CALL CGGBAK( 'P', 'R', N, ILO, IHI, RWORK( ILEFT ),
00527      $                   RWORK( IRIGHT ), N, VR, LDVR, IERR )
00528             DO 60 JC = 1, N
00529                TEMP = ZERO
00530                DO 40 JR = 1, N
00531                   TEMP = MAX( TEMP, ABS1( VR( JR, JC ) ) )
00532    40          CONTINUE
00533                IF( TEMP.LT.SMLNUM )
00534      $            GO TO 60
00535                TEMP = ONE / TEMP
00536                DO 50 JR = 1, N
00537                   VR( JR, JC ) = VR( JR, JC )*TEMP
00538    50          CONTINUE
00539    60       CONTINUE
00540          END IF
00541       END IF
00542 *
00543 *     Undo scaling if necessary
00544 *
00545    70 CONTINUE
00546 *
00547       IF( ILASCL )
00548      $   CALL CLASCL( 'G', 0, 0, ANRMTO, ANRM, N, 1, ALPHA, N, IERR )
00549 *
00550       IF( ILBSCL )
00551      $   CALL CLASCL( 'G', 0, 0, BNRMTO, BNRM, N, 1, BETA, N, IERR )
00552 *
00553       WORK( 1 ) = LWKOPT
00554       RETURN
00555 *
00556 *     End of CGGEV
00557 *
00558       END
 All Files Functions