version 1.1.1.1, 2010/01/26 15:22:46
|
version 1.20, 2023/08/07 08:38:48
|
Line 1
|
Line 1
|
|
*> \brief <b> DGEESX computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices</b> |
|
* |
|
* =========== DOCUMENTATION =========== |
|
* |
|
* Online html documentation available at |
|
* http://www.netlib.org/lapack/explore-html/ |
|
* |
|
*> \htmlonly |
|
*> Download DGEESX + dependencies |
|
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dgeesx.f"> |
|
*> [TGZ]</a> |
|
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dgeesx.f"> |
|
*> [ZIP]</a> |
|
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dgeesx.f"> |
|
*> [TXT]</a> |
|
*> \endhtmlonly |
|
* |
|
* Definition: |
|
* =========== |
|
* |
|
* SUBROUTINE DGEESX( JOBVS, SORT, SELECT, SENSE, N, A, LDA, SDIM, |
|
* WR, WI, VS, LDVS, RCONDE, RCONDV, WORK, LWORK, |
|
* IWORK, LIWORK, BWORK, INFO ) |
|
* |
|
* .. Scalar Arguments .. |
|
* CHARACTER JOBVS, SENSE, SORT |
|
* INTEGER INFO, LDA, LDVS, LIWORK, LWORK, N, SDIM |
|
* DOUBLE PRECISION RCONDE, RCONDV |
|
* .. |
|
* .. Array Arguments .. |
|
* LOGICAL BWORK( * ) |
|
* INTEGER IWORK( * ) |
|
* DOUBLE PRECISION A( LDA, * ), VS( LDVS, * ), WI( * ), WORK( * ), |
|
* $ WR( * ) |
|
* .. |
|
* .. Function Arguments .. |
|
* LOGICAL SELECT |
|
* EXTERNAL SELECT |
|
* .. |
|
* |
|
* |
|
*> \par Purpose: |
|
* ============= |
|
*> |
|
*> \verbatim |
|
*> |
|
*> DGEESX computes for an N-by-N real nonsymmetric matrix A, the |
|
*> eigenvalues, the real Schur form T, and, optionally, the matrix of |
|
*> Schur vectors Z. This gives the Schur factorization A = Z*T*(Z**T). |
|
*> |
|
*> Optionally, it also orders the eigenvalues on the diagonal of the |
|
*> real Schur form so that selected eigenvalues are at the top left; |
|
*> computes a reciprocal condition number for the average of the |
|
*> selected eigenvalues (RCONDE); and computes a reciprocal condition |
|
*> number for the right invariant subspace corresponding to the |
|
*> selected eigenvalues (RCONDV). The leading columns of Z form an |
|
*> orthonormal basis for this invariant subspace. |
|
*> |
|
*> For further explanation of the reciprocal condition numbers RCONDE |
|
*> and RCONDV, see Section 4.10 of the LAPACK Users' Guide (where |
|
*> these quantities are called s and sep respectively). |
|
*> |
|
*> A real matrix is in real Schur form if it is upper quasi-triangular |
|
*> with 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in |
|
*> the form |
|
*> [ a b ] |
|
*> [ c a ] |
|
*> |
|
*> where b*c < 0. The eigenvalues of such a block are a +- sqrt(bc). |
|
*> \endverbatim |
|
* |
|
* Arguments: |
|
* ========== |
|
* |
|
*> \param[in] JOBVS |
|
*> \verbatim |
|
*> JOBVS is CHARACTER*1 |
|
*> = 'N': Schur vectors are not computed; |
|
*> = 'V': Schur vectors are computed. |
|
*> \endverbatim |
|
*> |
|
*> \param[in] SORT |
|
*> \verbatim |
|
*> SORT is CHARACTER*1 |
|
*> Specifies whether or not to order the eigenvalues on the |
|
*> diagonal of the Schur form. |
|
*> = 'N': Eigenvalues are not ordered; |
|
*> = 'S': Eigenvalues are ordered (see SELECT). |
|
*> \endverbatim |
|
*> |
|
*> \param[in] SELECT |
|
*> \verbatim |
|
*> SELECT is a LOGICAL FUNCTION of two DOUBLE PRECISION arguments |
|
*> SELECT must be declared EXTERNAL in the calling subroutine. |
|
*> If SORT = 'S', SELECT is used to select eigenvalues to sort |
|
*> to the top left of the Schur form. |
|
*> If SORT = 'N', SELECT is not referenced. |
|
*> An eigenvalue WR(j)+sqrt(-1)*WI(j) is selected if |
|
*> SELECT(WR(j),WI(j)) is true; i.e., if either one of a |
|
*> complex conjugate pair of eigenvalues is selected, then both |
|
*> are. Note that a selected complex eigenvalue may no longer |
|
*> satisfy SELECT(WR(j),WI(j)) = .TRUE. after ordering, since |
|
*> ordering may change the value of complex eigenvalues |
|
*> (especially if the eigenvalue is ill-conditioned); in this |
|
*> case INFO may be set to N+3 (see INFO below). |
|
*> \endverbatim |
|
*> |
|
*> \param[in] SENSE |
|
*> \verbatim |
|
*> SENSE is CHARACTER*1 |
|
*> Determines which reciprocal condition numbers are computed. |
|
*> = 'N': None are computed; |
|
*> = 'E': Computed for average of selected eigenvalues only; |
|
*> = 'V': Computed for selected right invariant subspace only; |
|
*> = 'B': Computed for both. |
|
*> If SENSE = 'E', 'V' or 'B', SORT must equal 'S'. |
|
*> \endverbatim |
|
*> |
|
*> \param[in] N |
|
*> \verbatim |
|
*> N is INTEGER |
|
*> The order of the matrix A. N >= 0. |
|
*> \endverbatim |
|
*> |
|
*> \param[in,out] A |
|
*> \verbatim |
|
*> A is DOUBLE PRECISION array, dimension (LDA, N) |
|
*> On entry, the N-by-N matrix A. |
|
*> On exit, A is overwritten by its real Schur form T. |
|
*> \endverbatim |
|
*> |
|
*> \param[in] LDA |
|
*> \verbatim |
|
*> LDA is INTEGER |
|
*> The leading dimension of the array A. LDA >= max(1,N). |
|
*> \endverbatim |
|
*> |
|
*> \param[out] SDIM |
|
*> \verbatim |
|
*> SDIM is INTEGER |
|
*> If SORT = 'N', SDIM = 0. |
|
*> If SORT = 'S', SDIM = number of eigenvalues (after sorting) |
|
*> for which SELECT is true. (Complex conjugate |
|
*> pairs for which SELECT is true for either |
|
*> eigenvalue count as 2.) |
|
*> \endverbatim |
|
*> |
|
*> \param[out] WR |
|
*> \verbatim |
|
*> WR is DOUBLE PRECISION array, dimension (N) |
|
*> \endverbatim |
|
*> |
|
*> \param[out] WI |
|
*> \verbatim |
|
*> WI is DOUBLE PRECISION array, dimension (N) |
|
*> WR and WI contain the real and imaginary parts, respectively, |
|
*> of the computed eigenvalues, in the same order that they |
|
*> appear on the diagonal of the output Schur form T. Complex |
|
*> conjugate pairs of eigenvalues appear consecutively with the |
|
*> eigenvalue having the positive imaginary part first. |
|
*> \endverbatim |
|
*> |
|
*> \param[out] VS |
|
*> \verbatim |
|
*> VS is DOUBLE PRECISION array, dimension (LDVS,N) |
|
*> If JOBVS = 'V', VS contains the orthogonal matrix Z of Schur |
|
*> vectors. |
|
*> If JOBVS = 'N', VS is not referenced. |
|
*> \endverbatim |
|
*> |
|
*> \param[in] LDVS |
|
*> \verbatim |
|
*> LDVS is INTEGER |
|
*> The leading dimension of the array VS. LDVS >= 1, and if |
|
*> JOBVS = 'V', LDVS >= N. |
|
*> \endverbatim |
|
*> |
|
*> \param[out] RCONDE |
|
*> \verbatim |
|
*> RCONDE is DOUBLE PRECISION |
|
*> If SENSE = 'E' or 'B', RCONDE contains the reciprocal |
|
*> condition number for the average of the selected eigenvalues. |
|
*> Not referenced if SENSE = 'N' or 'V'. |
|
*> \endverbatim |
|
*> |
|
*> \param[out] RCONDV |
|
*> \verbatim |
|
*> RCONDV is DOUBLE PRECISION |
|
*> If SENSE = 'V' or 'B', RCONDV contains the reciprocal |
|
*> condition number for the selected right invariant subspace. |
|
*> Not referenced if SENSE = 'N' or 'E'. |
|
*> \endverbatim |
|
*> |
|
*> \param[out] WORK |
|
*> \verbatim |
|
*> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)) |
|
*> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. |
|
*> \endverbatim |
|
*> |
|
*> \param[in] LWORK |
|
*> \verbatim |
|
*> LWORK is INTEGER |
|
*> The dimension of the array WORK. LWORK >= max(1,3*N). |
|
*> Also, if SENSE = 'E' or 'V' or 'B', |
|
*> LWORK >= N+2*SDIM*(N-SDIM), where SDIM is the number of |
|
*> selected eigenvalues computed by this routine. Note that |
|
*> N+2*SDIM*(N-SDIM) <= N+N*N/2. Note also that an error is only |
|
*> returned if LWORK < max(1,3*N), but if SENSE = 'E' or 'V' or |
|
*> 'B' this may not be large enough. |
|
*> For good performance, LWORK must generally be larger. |
|
*> |
|
*> If LWORK = -1, then a workspace query is assumed; the routine |
|
*> only calculates upper bounds on the optimal sizes of the |
|
*> arrays WORK and IWORK, returns these values as the first |
|
*> entries of the WORK and IWORK arrays, and no error messages |
|
*> related to LWORK or LIWORK are issued by XERBLA. |
|
*> \endverbatim |
|
*> |
|
*> \param[out] IWORK |
|
*> \verbatim |
|
*> IWORK is INTEGER array, dimension (MAX(1,LIWORK)) |
|
*> On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. |
|
*> \endverbatim |
|
*> |
|
*> \param[in] LIWORK |
|
*> \verbatim |
|
*> LIWORK is INTEGER |
|
*> The dimension of the array IWORK. |
|
*> LIWORK >= 1; if SENSE = 'V' or 'B', LIWORK >= SDIM*(N-SDIM). |
|
*> Note that SDIM*(N-SDIM) <= N*N/4. Note also that an error is |
|
*> only returned if LIWORK < 1, but if SENSE = 'V' or 'B' this |
|
*> may not be large enough. |
|
*> |
|
*> If LIWORK = -1, then a workspace query is assumed; the |
|
*> routine only calculates upper bounds on the optimal sizes of |
|
*> the arrays WORK and IWORK, returns these values as the first |
|
*> entries of the WORK and IWORK arrays, and no error messages |
|
*> related to LWORK or LIWORK are issued by XERBLA. |
|
*> \endverbatim |
|
*> |
|
*> \param[out] BWORK |
|
*> \verbatim |
|
*> BWORK is LOGICAL array, dimension (N) |
|
*> Not referenced if SORT = 'N'. |
|
*> \endverbatim |
|
*> |
|
*> \param[out] INFO |
|
*> \verbatim |
|
*> INFO is INTEGER |
|
*> = 0: successful exit |
|
*> < 0: if INFO = -i, the i-th argument had an illegal value. |
|
*> > 0: if INFO = i, and i is |
|
*> <= N: the QR algorithm failed to compute all the |
|
*> eigenvalues; elements 1:ILO-1 and i+1:N of WR and WI |
|
*> contain those eigenvalues which have converged; if |
|
*> JOBVS = 'V', VS contains the transformation which |
|
*> reduces A to its partially converged Schur form. |
|
*> = N+1: the eigenvalues could not be reordered because some |
|
*> eigenvalues were too close to separate (the problem |
|
*> is very ill-conditioned); |
|
*> = N+2: after reordering, roundoff changed values of some |
|
*> complex eigenvalues so that leading eigenvalues in |
|
*> the Schur form no longer satisfy SELECT=.TRUE. This |
|
*> could also be caused by underflow due to scaling. |
|
*> \endverbatim |
|
* |
|
* Authors: |
|
* ======== |
|
* |
|
*> \author Univ. of Tennessee |
|
*> \author Univ. of California Berkeley |
|
*> \author Univ. of Colorado Denver |
|
*> \author NAG Ltd. |
|
* |
|
*> \ingroup doubleGEeigen |
|
* |
|
* ===================================================================== |
SUBROUTINE DGEESX( JOBVS, SORT, SELECT, SENSE, N, A, LDA, SDIM, |
SUBROUTINE DGEESX( JOBVS, SORT, SELECT, SENSE, N, A, LDA, SDIM, |
$ WR, WI, VS, LDVS, RCONDE, RCONDV, WORK, LWORK, |
$ WR, WI, VS, LDVS, RCONDE, RCONDV, WORK, LWORK, |
$ IWORK, LIWORK, BWORK, INFO ) |
$ IWORK, LIWORK, BWORK, INFO ) |
* |
* |
* -- LAPACK driver routine (version 3.2) -- |
* -- LAPACK driver routine -- |
* -- LAPACK is a software package provided by Univ. of Tennessee, -- |
* -- LAPACK is a software package provided by Univ. of Tennessee, -- |
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- |
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- |
* November 2006 |
|
* |
* |
* .. Scalar Arguments .. |
* .. Scalar Arguments .. |
CHARACTER JOBVS, SENSE, SORT |
CHARACTER JOBVS, SENSE, SORT |
Line 23
|
Line 299
|
EXTERNAL SELECT |
EXTERNAL SELECT |
* .. |
* .. |
* |
* |
* Purpose |
|
* ======= |
|
* |
|
* DGEESX computes for an N-by-N real nonsymmetric matrix A, the |
|
* eigenvalues, the real Schur form T, and, optionally, the matrix of |
|
* Schur vectors Z. This gives the Schur factorization A = Z*T*(Z**T). |
|
* |
|
* Optionally, it also orders the eigenvalues on the diagonal of the |
|
* real Schur form so that selected eigenvalues are at the top left; |
|
* computes a reciprocal condition number for the average of the |
|
* selected eigenvalues (RCONDE); and computes a reciprocal condition |
|
* number for the right invariant subspace corresponding to the |
|
* selected eigenvalues (RCONDV). The leading columns of Z form an |
|
* orthonormal basis for this invariant subspace. |
|
* |
|
* For further explanation of the reciprocal condition numbers RCONDE |
|
* and RCONDV, see Section 4.10 of the LAPACK Users' Guide (where |
|
* these quantities are called s and sep respectively). |
|
* |
|
* A real matrix is in real Schur form if it is upper quasi-triangular |
|
* with 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in |
|
* the form |
|
* [ a b ] |
|
* [ c a ] |
|
* |
|
* where b*c < 0. The eigenvalues of such a block are a +- sqrt(bc). |
|
* |
|
* Arguments |
|
* ========= |
|
* |
|
* JOBVS (input) CHARACTER*1 |
|
* = 'N': Schur vectors are not computed; |
|
* = 'V': Schur vectors are computed. |
|
* |
|
* SORT (input) CHARACTER*1 |
|
* Specifies whether or not to order the eigenvalues on the |
|
* diagonal of the Schur form. |
|
* = 'N': Eigenvalues are not ordered; |
|
* = 'S': Eigenvalues are ordered (see SELECT). |
|
* |
|
* SELECT (external procedure) LOGICAL FUNCTION of two DOUBLE PRECISION arguments |
|
* SELECT must be declared EXTERNAL in the calling subroutine. |
|
* If SORT = 'S', SELECT is used to select eigenvalues to sort |
|
* to the top left of the Schur form. |
|
* If SORT = 'N', SELECT is not referenced. |
|
* An eigenvalue WR(j)+sqrt(-1)*WI(j) is selected if |
|
* SELECT(WR(j),WI(j)) is true; i.e., if either one of a |
|
* complex conjugate pair of eigenvalues is selected, then both |
|
* are. Note that a selected complex eigenvalue may no longer |
|
* satisfy SELECT(WR(j),WI(j)) = .TRUE. after ordering, since |
|
* ordering may change the value of complex eigenvalues |
|
* (especially if the eigenvalue is ill-conditioned); in this |
|
* case INFO may be set to N+3 (see INFO below). |
|
* |
|
* SENSE (input) CHARACTER*1 |
|
* Determines which reciprocal condition numbers are computed. |
|
* = 'N': None are computed; |
|
* = 'E': Computed for average of selected eigenvalues only; |
|
* = 'V': Computed for selected right invariant subspace only; |
|
* = 'B': Computed for both. |
|
* If SENSE = 'E', 'V' or 'B', SORT must equal 'S'. |
|
* |
|
* N (input) INTEGER |
|
* The order of the matrix A. N >= 0. |
|
* |
|
* A (input/output) DOUBLE PRECISION array, dimension (LDA, N) |
|
* On entry, the N-by-N matrix A. |
|
* On exit, A is overwritten by its real Schur form T. |
|
* |
|
* LDA (input) INTEGER |
|
* The leading dimension of the array A. LDA >= max(1,N). |
|
* |
|
* SDIM (output) INTEGER |
|
* If SORT = 'N', SDIM = 0. |
|
* If SORT = 'S', SDIM = number of eigenvalues (after sorting) |
|
* for which SELECT is true. (Complex conjugate |
|
* pairs for which SELECT is true for either |
|
* eigenvalue count as 2.) |
|
* |
|
* WR (output) DOUBLE PRECISION array, dimension (N) |
|
* WI (output) DOUBLE PRECISION array, dimension (N) |
|
* WR and WI contain the real and imaginary parts, respectively, |
|
* of the computed eigenvalues, in the same order that they |
|
* appear on the diagonal of the output Schur form T. Complex |
|
* conjugate pairs of eigenvalues appear consecutively with the |
|
* eigenvalue having the positive imaginary part first. |
|
* |
|
* VS (output) DOUBLE PRECISION array, dimension (LDVS,N) |
|
* If JOBVS = 'V', VS contains the orthogonal matrix Z of Schur |
|
* vectors. |
|
* If JOBVS = 'N', VS is not referenced. |
|
* |
|
* LDVS (input) INTEGER |
|
* The leading dimension of the array VS. LDVS >= 1, and if |
|
* JOBVS = 'V', LDVS >= N. |
|
* |
|
* RCONDE (output) DOUBLE PRECISION |
|
* If SENSE = 'E' or 'B', RCONDE contains the reciprocal |
|
* condition number for the average of the selected eigenvalues. |
|
* Not referenced if SENSE = 'N' or 'V'. |
|
* |
|
* RCONDV (output) DOUBLE PRECISION |
|
* If SENSE = 'V' or 'B', RCONDV contains the reciprocal |
|
* condition number for the selected right invariant subspace. |
|
* Not referenced if SENSE = 'N' or 'E'. |
|
* |
|
* WORK (workspace/output) DOUBLE PRECISION array, dimension (MAX(1,LWORK)) |
|
* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. |
|
* |
|
* LWORK (input) INTEGER |
|
* The dimension of the array WORK. LWORK >= max(1,3*N). |
|
* Also, if SENSE = 'E' or 'V' or 'B', |
|
* LWORK >= N+2*SDIM*(N-SDIM), where SDIM is the number of |
|
* selected eigenvalues computed by this routine. Note that |
|
* N+2*SDIM*(N-SDIM) <= N+N*N/2. Note also that an error is only |
|
* returned if LWORK < max(1,3*N), but if SENSE = 'E' or 'V' or |
|
* 'B' this may not be large enough. |
|
* For good performance, LWORK must generally be larger. |
|
* |
|
* If LWORK = -1, then a workspace query is assumed; the routine |
|
* only calculates upper bounds on the optimal sizes of the |
|
* arrays WORK and IWORK, returns these values as the first |
|
* entries of the WORK and IWORK arrays, and no error messages |
|
* related to LWORK or LIWORK are issued by XERBLA. |
|
* |
|
* IWORK (workspace/output) INTEGER array, dimension (MAX(1,LIWORK)) |
|
* On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. |
|
* |
|
* LIWORK (input) INTEGER |
|
* The dimension of the array IWORK. |
|
* LIWORK >= 1; if SENSE = 'V' or 'B', LIWORK >= SDIM*(N-SDIM). |
|
* Note that SDIM*(N-SDIM) <= N*N/4. Note also that an error is |
|
* only returned if LIWORK < 1, but if SENSE = 'V' or 'B' this |
|
* may not be large enough. |
|
* |
|
* If LIWORK = -1, then a workspace query is assumed; the |
|
* routine only calculates upper bounds on the optimal sizes of |
|
* the arrays WORK and IWORK, returns these values as the first |
|
* entries of the WORK and IWORK arrays, and no error messages |
|
* related to LWORK or LIWORK are issued by XERBLA. |
|
* |
|
* BWORK (workspace) LOGICAL array, dimension (N) |
|
* Not referenced if SORT = 'N'. |
|
* |
|
* INFO (output) INTEGER |
|
* = 0: successful exit |
|
* < 0: if INFO = -i, the i-th argument had an illegal value. |
|
* > 0: if INFO = i, and i is |
|
* <= N: the QR algorithm failed to compute all the |
|
* eigenvalues; elements 1:ILO-1 and i+1:N of WR and WI |
|
* contain those eigenvalues which have converged; if |
|
* JOBVS = 'V', VS contains the transformation which |
|
* reduces A to its partially converged Schur form. |
|
* = N+1: the eigenvalues could not be reordered because some |
|
* eigenvalues were too close to separate (the problem |
|
* is very ill-conditioned); |
|
* = N+2: after reordering, roundoff changed values of some |
|
* complex eigenvalues so that leading eigenvalues in |
|
* the Schur form no longer satisfy SELECT=.TRUE. This |
|
* could also be caused by underflow due to scaling. |
|
* |
|
* ===================================================================== |
* ===================================================================== |
* |
* |
* .. Parameters .. |
* .. Parameters .. |
Line 226
|
Line 341
|
WANTSV = LSAME( SENSE, 'V' ) |
WANTSV = LSAME( SENSE, 'V' ) |
WANTSB = LSAME( SENSE, 'B' ) |
WANTSB = LSAME( SENSE, 'B' ) |
LQUERY = ( LWORK.EQ.-1 .OR. LIWORK.EQ.-1 ) |
LQUERY = ( LWORK.EQ.-1 .OR. LIWORK.EQ.-1 ) |
|
* |
IF( ( .NOT.WANTVS ) .AND. ( .NOT.LSAME( JOBVS, 'N' ) ) ) THEN |
IF( ( .NOT.WANTVS ) .AND. ( .NOT.LSAME( JOBVS, 'N' ) ) ) THEN |
INFO = -1 |
INFO = -1 |
ELSE IF( ( .NOT.WANTST ) .AND. ( .NOT.LSAME( SORT, 'N' ) ) ) THEN |
ELSE IF( ( .NOT.WANTST ) .AND. ( .NOT.LSAME( SORT, 'N' ) ) ) THEN |
Line 266
|
Line 382
|
* |
* |
CALL DHSEQR( 'S', JOBVS, N, 1, N, A, LDA, WR, WI, VS, LDVS, |
CALL DHSEQR( 'S', JOBVS, N, 1, N, A, LDA, WR, WI, VS, LDVS, |
$ WORK, -1, IEVAL ) |
$ WORK, -1, IEVAL ) |
HSWORK = WORK( 1 ) |
HSWORK = INT( WORK( 1 ) ) |
* |
* |
IF( .NOT.WANTVS ) THEN |
IF( .NOT.WANTVS ) THEN |
MAXWRK = MAX( MAXWRK, N + HSWORK ) |
MAXWRK = MAX( MAXWRK, N + HSWORK ) |
Line 294
|
Line 410
|
IF( INFO.NE.0 ) THEN |
IF( INFO.NE.0 ) THEN |
CALL XERBLA( 'DGEESX', -INFO ) |
CALL XERBLA( 'DGEESX', -INFO ) |
RETURN |
RETURN |
|
ELSE IF( LQUERY ) THEN |
|
RETURN |
END IF |
END IF |
* |
* |
* Quick return if possible |
* Quick return if possible |
Line 462
|
Line 580
|
IF( N.GT.I+1 ) |
IF( N.GT.I+1 ) |
$ CALL DSWAP( N-I-1, A( I, I+2 ), LDA, |
$ CALL DSWAP( N-I-1, A( I, I+2 ), LDA, |
$ A( I+1, I+2 ), LDA ) |
$ A( I+1, I+2 ), LDA ) |
CALL DSWAP( N, VS( 1, I ), 1, VS( 1, I+1 ), 1 ) |
IF( WANTVS ) THEN |
|
CALL DSWAP( N, VS( 1, I ), 1, VS( 1, I+1 ), 1 ) |
|
END IF |
A( I, I+1 ) = A( I+1, I ) |
A( I, I+1 ) = A( I+1, I ) |
A( I+1, I ) = ZERO |
A( I+1, I ) = ZERO |
END IF |
END IF |