![]() |
LAPACK
3.4.1
LAPACK: Linear Algebra PACKage
|
00001 *> \brief <b> DGEEVX 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 DGEGS + dependencies 00010 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dgegs.f"> 00011 *> [TGZ]</a> 00012 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dgegs.f"> 00013 *> [ZIP]</a> 00014 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dgegs.f"> 00015 *> [TXT]</a> 00016 *> \endhtmlonly 00017 * 00018 * Definition: 00019 * =========== 00020 * 00021 * SUBROUTINE DGEGS( JOBVSL, JOBVSR, N, A, LDA, B, LDB, ALPHAR, 00022 * ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR, WORK, 00023 * LWORK, INFO ) 00024 * 00025 * .. Scalar Arguments .. 00026 * CHARACTER JOBVSL, JOBVSR 00027 * INTEGER INFO, LDA, LDB, LDVSL, LDVSR, LWORK, N 00028 * .. 00029 * .. Array Arguments .. 00030 * DOUBLE PRECISION A( LDA, * ), ALPHAI( * ), ALPHAR( * ), 00031 * $ B( LDB, * ), BETA( * ), VSL( LDVSL, * ), 00032 * $ VSR( LDVSR, * ), WORK( * ) 00033 * .. 00034 * 00035 * 00036 *> \par Purpose: 00037 * ============= 00038 *> 00039 *> \verbatim 00040 *> 00041 *> This routine is deprecated and has been replaced by routine DGGES. 00042 *> 00043 *> DGEGS computes the eigenvalues, real Schur form, and, optionally, 00044 *> left and or/right Schur vectors of a real matrix pair (A,B). 00045 *> Given two square matrices A and B, the generalized real Schur 00046 *> factorization has the form 00047 *> 00048 *> A = Q*S*Z**T, B = Q*T*Z**T 00049 *> 00050 *> where Q and Z are orthogonal matrices, T is upper triangular, and S 00051 *> is an upper quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal 00052 *> blocks, the 2-by-2 blocks corresponding to complex conjugate pairs 00053 *> of eigenvalues of (A,B). The columns of Q are the left Schur vectors 00054 *> and the columns of Z are the right Schur vectors. 00055 *> 00056 *> If only the eigenvalues of (A,B) are needed, the driver routine 00057 *> DGEGV should be used instead. See DGEGV for a description of the 00058 *> eigenvalues of the generalized nonsymmetric eigenvalue problem 00059 *> (GNEP). 00060 *> \endverbatim 00061 * 00062 * Arguments: 00063 * ========== 00064 * 00065 *> \param[in] JOBVSL 00066 *> \verbatim 00067 *> JOBVSL is CHARACTER*1 00068 *> = 'N': do not compute the left Schur vectors; 00069 *> = 'V': compute the left Schur vectors (returned in VSL). 00070 *> \endverbatim 00071 *> 00072 *> \param[in] JOBVSR 00073 *> \verbatim 00074 *> JOBVSR is CHARACTER*1 00075 *> = 'N': do not compute the right Schur vectors; 00076 *> = 'V': compute the right Schur vectors (returned in VSR). 00077 *> \endverbatim 00078 *> 00079 *> \param[in] N 00080 *> \verbatim 00081 *> N is INTEGER 00082 *> The order of the matrices A, B, VSL, and VSR. N >= 0. 00083 *> \endverbatim 00084 *> 00085 *> \param[in,out] A 00086 *> \verbatim 00087 *> A is DOUBLE PRECISION array, dimension (LDA, N) 00088 *> On entry, the matrix A. 00089 *> On exit, the upper quasi-triangular matrix S from the 00090 *> generalized real Schur factorization. 00091 *> \endverbatim 00092 *> 00093 *> \param[in] LDA 00094 *> \verbatim 00095 *> LDA is INTEGER 00096 *> The leading dimension of A. LDA >= max(1,N). 00097 *> \endverbatim 00098 *> 00099 *> \param[in,out] B 00100 *> \verbatim 00101 *> B is DOUBLE PRECISION array, dimension (LDB, N) 00102 *> On entry, the matrix B. 00103 *> On exit, the upper triangular matrix T from the generalized 00104 *> real Schur factorization. 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] ALPHAR 00114 *> \verbatim 00115 *> ALPHAR is DOUBLE PRECISION array, dimension (N) 00116 *> The real parts of each scalar alpha defining an eigenvalue 00117 *> of GNEP. 00118 *> \endverbatim 00119 *> 00120 *> \param[out] ALPHAI 00121 *> \verbatim 00122 *> ALPHAI is DOUBLE PRECISION array, dimension (N) 00123 *> The imaginary parts of each scalar alpha defining an 00124 *> eigenvalue of GNEP. If ALPHAI(j) is zero, then the j-th 00125 *> eigenvalue is real; if positive, then the j-th and (j+1)-st 00126 *> eigenvalues are a complex conjugate pair, with 00127 *> ALPHAI(j+1) = -ALPHAI(j). 00128 *> \endverbatim 00129 *> 00130 *> \param[out] BETA 00131 *> \verbatim 00132 *> BETA is DOUBLE PRECISION array, dimension (N) 00133 *> The scalars beta that define the eigenvalues of GNEP. 00134 *> Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and 00135 *> beta = BETA(j) represent the j-th eigenvalue of the matrix 00136 *> pair (A,B), in one of the forms lambda = alpha/beta or 00137 *> mu = beta/alpha. Since either lambda or mu may overflow, 00138 *> they should not, in general, be computed. 00139 *> \endverbatim 00140 *> 00141 *> \param[out] VSL 00142 *> \verbatim 00143 *> VSL is DOUBLE PRECISION array, dimension (LDVSL,N) 00144 *> If JOBVSL = 'V', the matrix of left Schur vectors Q. 00145 *> Not referenced if JOBVSL = 'N'. 00146 *> \endverbatim 00147 *> 00148 *> \param[in] LDVSL 00149 *> \verbatim 00150 *> LDVSL is INTEGER 00151 *> The leading dimension of the matrix VSL. LDVSL >=1, and 00152 *> if JOBVSL = 'V', LDVSL >= N. 00153 *> \endverbatim 00154 *> 00155 *> \param[out] VSR 00156 *> \verbatim 00157 *> VSR is DOUBLE PRECISION array, dimension (LDVSR,N) 00158 *> If JOBVSR = 'V', the matrix of right Schur vectors Z. 00159 *> Not referenced if JOBVSR = 'N'. 00160 *> \endverbatim 00161 *> 00162 *> \param[in] LDVSR 00163 *> \verbatim 00164 *> LDVSR is INTEGER 00165 *> The leading dimension of the matrix VSR. LDVSR >= 1, and 00166 *> if JOBVSR = 'V', LDVSR >= N. 00167 *> \endverbatim 00168 *> 00169 *> \param[out] WORK 00170 *> \verbatim 00171 *> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)) 00172 *> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. 00173 *> \endverbatim 00174 *> 00175 *> \param[in] LWORK 00176 *> \verbatim 00177 *> LWORK is INTEGER 00178 *> The dimension of the array WORK. LWORK >= max(1,4*N). 00179 *> For good performance, LWORK must generally be larger. 00180 *> To compute the optimal value of LWORK, call ILAENV to get 00181 *> blocksizes (for DGEQRF, DORMQR, and DORGQR.) Then compute: 00182 *> NB -- MAX of the blocksizes for DGEQRF, DORMQR, and DORGQR 00183 *> The optimal LWORK is 2*N + N*(NB+1). 00184 *> 00185 *> If LWORK = -1, then a workspace query is assumed; the routine 00186 *> only calculates the optimal size of the WORK array, returns 00187 *> this value as the first entry of the WORK array, and no error 00188 *> message related to LWORK is issued by XERBLA. 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. (A,B) are not in Schur 00198 *> form, but ALPHAR(j), ALPHAI(j), and BETA(j) should 00199 *> be correct for j=INFO+1,...,N. 00200 *> > N: errors that usually indicate LAPACK problems: 00201 *> =N+1: error return from DGGBAL 00202 *> =N+2: error return from DGEQRF 00203 *> =N+3: error return from DORMQR 00204 *> =N+4: error return from DORGQR 00205 *> =N+5: error return from DGGHRD 00206 *> =N+6: error return from DHGEQZ (other than failed 00207 *> iteration) 00208 *> =N+7: error return from DGGBAK (computing VSL) 00209 *> =N+8: error return from DGGBAK (computing VSR) 00210 *> =N+9: error return from DLASCL (various places) 00211 *> \endverbatim 00212 * 00213 * Authors: 00214 * ======== 00215 * 00216 *> \author Univ. of Tennessee 00217 *> \author Univ. of California Berkeley 00218 *> \author Univ. of Colorado Denver 00219 *> \author NAG Ltd. 00220 * 00221 *> \date November 2011 00222 * 00223 *> \ingroup doubleGEeigen 00224 * 00225 * ===================================================================== 00226 SUBROUTINE DGEGS( JOBVSL, JOBVSR, N, A, LDA, B, LDB, ALPHAR, 00227 $ ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR, WORK, 00228 $ LWORK, INFO ) 00229 * 00230 * -- LAPACK driver routine (version 3.4.0) -- 00231 * -- LAPACK is a software package provided by Univ. of Tennessee, -- 00232 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- 00233 * November 2011 00234 * 00235 * .. Scalar Arguments .. 00236 CHARACTER JOBVSL, JOBVSR 00237 INTEGER INFO, LDA, LDB, LDVSL, LDVSR, LWORK, N 00238 * .. 00239 * .. Array Arguments .. 00240 DOUBLE PRECISION A( LDA, * ), ALPHAI( * ), ALPHAR( * ), 00241 $ B( LDB, * ), BETA( * ), VSL( LDVSL, * ), 00242 $ VSR( LDVSR, * ), WORK( * ) 00243 * .. 00244 * 00245 * ===================================================================== 00246 * 00247 * .. Parameters .. 00248 DOUBLE PRECISION ZERO, ONE 00249 PARAMETER ( ZERO = 0.0D0, ONE = 1.0D0 ) 00250 * .. 00251 * .. Local Scalars .. 00252 LOGICAL ILASCL, ILBSCL, ILVSL, ILVSR, LQUERY 00253 INTEGER ICOLS, IHI, IINFO, IJOBVL, IJOBVR, ILEFT, ILO, 00254 $ IRIGHT, IROWS, ITAU, IWORK, LOPT, LWKMIN, 00255 $ LWKOPT, NB, NB1, NB2, NB3 00256 DOUBLE PRECISION ANRM, ANRMTO, BIGNUM, BNRM, BNRMTO, EPS, 00257 $ SAFMIN, SMLNUM 00258 * .. 00259 * .. External Subroutines .. 00260 EXTERNAL DGEQRF, DGGBAK, DGGBAL, DGGHRD, DHGEQZ, DLACPY, 00261 $ DLASCL, DLASET, DORGQR, DORMQR, XERBLA 00262 * .. 00263 * .. External Functions .. 00264 LOGICAL LSAME 00265 INTEGER ILAENV 00266 DOUBLE PRECISION DLAMCH, DLANGE 00267 EXTERNAL LSAME, ILAENV, DLAMCH, DLANGE 00268 * .. 00269 * .. Intrinsic Functions .. 00270 INTRINSIC INT, MAX 00271 * .. 00272 * .. Executable Statements .. 00273 * 00274 * Decode the input arguments 00275 * 00276 IF( LSAME( JOBVSL, 'N' ) ) THEN 00277 IJOBVL = 1 00278 ILVSL = .FALSE. 00279 ELSE IF( LSAME( JOBVSL, 'V' ) ) THEN 00280 IJOBVL = 2 00281 ILVSL = .TRUE. 00282 ELSE 00283 IJOBVL = -1 00284 ILVSL = .FALSE. 00285 END IF 00286 * 00287 IF( LSAME( JOBVSR, 'N' ) ) THEN 00288 IJOBVR = 1 00289 ILVSR = .FALSE. 00290 ELSE IF( LSAME( JOBVSR, 'V' ) ) THEN 00291 IJOBVR = 2 00292 ILVSR = .TRUE. 00293 ELSE 00294 IJOBVR = -1 00295 ILVSR = .FALSE. 00296 END IF 00297 * 00298 * Test the input arguments 00299 * 00300 LWKMIN = MAX( 4*N, 1 ) 00301 LWKOPT = LWKMIN 00302 WORK( 1 ) = LWKOPT 00303 LQUERY = ( LWORK.EQ.-1 ) 00304 INFO = 0 00305 IF( IJOBVL.LE.0 ) THEN 00306 INFO = -1 00307 ELSE IF( IJOBVR.LE.0 ) THEN 00308 INFO = -2 00309 ELSE IF( N.LT.0 ) THEN 00310 INFO = -3 00311 ELSE IF( LDA.LT.MAX( 1, N ) ) THEN 00312 INFO = -5 00313 ELSE IF( LDB.LT.MAX( 1, N ) ) THEN 00314 INFO = -7 00315 ELSE IF( LDVSL.LT.1 .OR. ( ILVSL .AND. LDVSL.LT.N ) ) THEN 00316 INFO = -12 00317 ELSE IF( LDVSR.LT.1 .OR. ( ILVSR .AND. LDVSR.LT.N ) ) THEN 00318 INFO = -14 00319 ELSE IF( LWORK.LT.LWKMIN .AND. .NOT.LQUERY ) THEN 00320 INFO = -16 00321 END IF 00322 * 00323 IF( INFO.EQ.0 ) THEN 00324 NB1 = ILAENV( 1, 'DGEQRF', ' ', N, N, -1, -1 ) 00325 NB2 = ILAENV( 1, 'DORMQR', ' ', N, N, N, -1 ) 00326 NB3 = ILAENV( 1, 'DORGQR', ' ', N, N, N, -1 ) 00327 NB = MAX( NB1, NB2, NB3 ) 00328 LOPT = 2*N + N*( NB+1 ) 00329 WORK( 1 ) = LOPT 00330 END IF 00331 * 00332 IF( INFO.NE.0 ) THEN 00333 CALL XERBLA( 'DGEGS ', -INFO ) 00334 RETURN 00335 ELSE IF( LQUERY ) THEN 00336 RETURN 00337 END IF 00338 * 00339 * Quick return if possible 00340 * 00341 IF( N.EQ.0 ) 00342 $ RETURN 00343 * 00344 * Get machine constants 00345 * 00346 EPS = DLAMCH( 'E' )*DLAMCH( 'B' ) 00347 SAFMIN = DLAMCH( 'S' ) 00348 SMLNUM = N*SAFMIN / EPS 00349 BIGNUM = ONE / SMLNUM 00350 * 00351 * Scale A if max element outside range [SMLNUM,BIGNUM] 00352 * 00353 ANRM = DLANGE( 'M', N, N, A, LDA, WORK ) 00354 ILASCL = .FALSE. 00355 IF( ANRM.GT.ZERO .AND. ANRM.LT.SMLNUM ) THEN 00356 ANRMTO = SMLNUM 00357 ILASCL = .TRUE. 00358 ELSE IF( ANRM.GT.BIGNUM ) THEN 00359 ANRMTO = BIGNUM 00360 ILASCL = .TRUE. 00361 END IF 00362 * 00363 IF( ILASCL ) THEN 00364 CALL DLASCL( 'G', -1, -1, ANRM, ANRMTO, N, N, A, LDA, IINFO ) 00365 IF( IINFO.NE.0 ) THEN 00366 INFO = N + 9 00367 RETURN 00368 END IF 00369 END IF 00370 * 00371 * Scale B if max element outside range [SMLNUM,BIGNUM] 00372 * 00373 BNRM = DLANGE( 'M', N, N, B, LDB, WORK ) 00374 ILBSCL = .FALSE. 00375 IF( BNRM.GT.ZERO .AND. BNRM.LT.SMLNUM ) THEN 00376 BNRMTO = SMLNUM 00377 ILBSCL = .TRUE. 00378 ELSE IF( BNRM.GT.BIGNUM ) THEN 00379 BNRMTO = BIGNUM 00380 ILBSCL = .TRUE. 00381 END IF 00382 * 00383 IF( ILBSCL ) THEN 00384 CALL DLASCL( 'G', -1, -1, BNRM, BNRMTO, N, N, B, LDB, IINFO ) 00385 IF( IINFO.NE.0 ) THEN 00386 INFO = N + 9 00387 RETURN 00388 END IF 00389 END IF 00390 * 00391 * Permute the matrix to make it more nearly triangular 00392 * Workspace layout: (2*N words -- "work..." not actually used) 00393 * left_permutation, right_permutation, work... 00394 * 00395 ILEFT = 1 00396 IRIGHT = N + 1 00397 IWORK = IRIGHT + N 00398 CALL DGGBAL( 'P', N, A, LDA, B, LDB, ILO, IHI, WORK( ILEFT ), 00399 $ WORK( IRIGHT ), WORK( IWORK ), IINFO ) 00400 IF( IINFO.NE.0 ) THEN 00401 INFO = N + 1 00402 GO TO 10 00403 END IF 00404 * 00405 * Reduce B to triangular form, and initialize VSL and/or VSR 00406 * Workspace layout: ("work..." must have at least N words) 00407 * left_permutation, right_permutation, tau, work... 00408 * 00409 IROWS = IHI + 1 - ILO 00410 ICOLS = N + 1 - ILO 00411 ITAU = IWORK 00412 IWORK = ITAU + IROWS 00413 CALL DGEQRF( IROWS, ICOLS, B( ILO, ILO ), LDB, WORK( ITAU ), 00414 $ WORK( IWORK ), LWORK+1-IWORK, IINFO ) 00415 IF( IINFO.GE.0 ) 00416 $ LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 ) 00417 IF( IINFO.NE.0 ) THEN 00418 INFO = N + 2 00419 GO TO 10 00420 END IF 00421 * 00422 CALL DORMQR( 'L', 'T', IROWS, ICOLS, IROWS, B( ILO, ILO ), LDB, 00423 $ WORK( ITAU ), A( ILO, ILO ), LDA, WORK( IWORK ), 00424 $ LWORK+1-IWORK, IINFO ) 00425 IF( IINFO.GE.0 ) 00426 $ LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 ) 00427 IF( IINFO.NE.0 ) THEN 00428 INFO = N + 3 00429 GO TO 10 00430 END IF 00431 * 00432 IF( ILVSL ) THEN 00433 CALL DLASET( 'Full', N, N, ZERO, ONE, VSL, LDVSL ) 00434 CALL DLACPY( 'L', IROWS-1, IROWS-1, B( ILO+1, ILO ), LDB, 00435 $ VSL( ILO+1, ILO ), LDVSL ) 00436 CALL DORGQR( IROWS, IROWS, IROWS, VSL( ILO, ILO ), LDVSL, 00437 $ WORK( ITAU ), WORK( IWORK ), LWORK+1-IWORK, 00438 $ IINFO ) 00439 IF( IINFO.GE.0 ) 00440 $ LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 ) 00441 IF( IINFO.NE.0 ) THEN 00442 INFO = N + 4 00443 GO TO 10 00444 END IF 00445 END IF 00446 * 00447 IF( ILVSR ) 00448 $ CALL DLASET( 'Full', N, N, ZERO, ONE, VSR, LDVSR ) 00449 * 00450 * Reduce to generalized Hessenberg form 00451 * 00452 CALL DGGHRD( JOBVSL, JOBVSR, N, ILO, IHI, A, LDA, B, LDB, VSL, 00453 $ LDVSL, VSR, LDVSR, IINFO ) 00454 IF( IINFO.NE.0 ) THEN 00455 INFO = N + 5 00456 GO TO 10 00457 END IF 00458 * 00459 * Perform QZ algorithm, computing Schur vectors if desired 00460 * Workspace layout: ("work..." must have at least 1 word) 00461 * left_permutation, right_permutation, work... 00462 * 00463 IWORK = ITAU 00464 CALL DHGEQZ( 'S', JOBVSL, JOBVSR, N, ILO, IHI, A, LDA, B, LDB, 00465 $ ALPHAR, ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR, 00466 $ WORK( IWORK ), LWORK+1-IWORK, IINFO ) 00467 IF( IINFO.GE.0 ) 00468 $ LWKOPT = MAX( LWKOPT, INT( WORK( IWORK ) )+IWORK-1 ) 00469 IF( IINFO.NE.0 ) THEN 00470 IF( IINFO.GT.0 .AND. IINFO.LE.N ) THEN 00471 INFO = IINFO 00472 ELSE IF( IINFO.GT.N .AND. IINFO.LE.2*N ) THEN 00473 INFO = IINFO - N 00474 ELSE 00475 INFO = N + 6 00476 END IF 00477 GO TO 10 00478 END IF 00479 * 00480 * Apply permutation to VSL and VSR 00481 * 00482 IF( ILVSL ) THEN 00483 CALL DGGBAK( 'P', 'L', N, ILO, IHI, WORK( ILEFT ), 00484 $ WORK( IRIGHT ), N, VSL, LDVSL, IINFO ) 00485 IF( IINFO.NE.0 ) THEN 00486 INFO = N + 7 00487 GO TO 10 00488 END IF 00489 END IF 00490 IF( ILVSR ) THEN 00491 CALL DGGBAK( 'P', 'R', N, ILO, IHI, WORK( ILEFT ), 00492 $ WORK( IRIGHT ), N, VSR, LDVSR, IINFO ) 00493 IF( IINFO.NE.0 ) THEN 00494 INFO = N + 8 00495 GO TO 10 00496 END IF 00497 END IF 00498 * 00499 * Undo scaling 00500 * 00501 IF( ILASCL ) THEN 00502 CALL DLASCL( 'H', -1, -1, ANRMTO, ANRM, N, N, A, LDA, IINFO ) 00503 IF( IINFO.NE.0 ) THEN 00504 INFO = N + 9 00505 RETURN 00506 END IF 00507 CALL DLASCL( 'G', -1, -1, ANRMTO, ANRM, N, 1, ALPHAR, N, 00508 $ IINFO ) 00509 IF( IINFO.NE.0 ) THEN 00510 INFO = N + 9 00511 RETURN 00512 END IF 00513 CALL DLASCL( 'G', -1, -1, ANRMTO, ANRM, N, 1, ALPHAI, N, 00514 $ IINFO ) 00515 IF( IINFO.NE.0 ) THEN 00516 INFO = N + 9 00517 RETURN 00518 END IF 00519 END IF 00520 * 00521 IF( ILBSCL ) THEN 00522 CALL DLASCL( 'U', -1, -1, BNRMTO, BNRM, N, N, B, LDB, IINFO ) 00523 IF( IINFO.NE.0 ) THEN 00524 INFO = N + 9 00525 RETURN 00526 END IF 00527 CALL DLASCL( 'G', -1, -1, BNRMTO, BNRM, N, 1, BETA, N, IINFO ) 00528 IF( IINFO.NE.0 ) THEN 00529 INFO = N + 9 00530 RETURN 00531 END IF 00532 END IF 00533 * 00534 10 CONTINUE 00535 WORK( 1 ) = LWKOPT 00536 * 00537 RETURN 00538 * 00539 * End of DGEGS 00540 * 00541 END