 LAPACK  3.9.1 LAPACK: Linear Algebra PACKage

## ◆ dgegs()

 subroutine dgegs ( character JOBVSL, character JOBVSR, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( ldvsl, * ) VSL, integer LDVSL, double precision, dimension( ldvsr, * ) VSR, integer LDVSR, double precision, dimension( * ) WORK, integer LWORK, integer INFO )

DGEEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices

Download DGEGS + dependencies [TGZ] [ZIP] [TXT]

Purpose:
``` This routine is deprecated and has been replaced by routine DGGES.

DGEGS computes the eigenvalues, real Schur form, and, optionally,
left and or/right Schur vectors of a real matrix pair (A,B).
Given two square matrices A and B, the generalized real Schur
factorization has the form

A = Q*S*Z**T,  B = Q*T*Z**T

where Q and Z are orthogonal matrices, T is upper triangular, and S
is an upper quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal
blocks, the 2-by-2 blocks corresponding to complex conjugate pairs
of eigenvalues of (A,B).  The columns of Q are the left Schur vectors
and the columns of Z are the right Schur vectors.

If only the eigenvalues of (A,B) are needed, the driver routine
DGEGV should be used instead.  See DGEGV for a description of the
eigenvalues of the generalized nonsymmetric eigenvalue problem
(GNEP).```
Parameters
 [in] JOBVSL ``` JOBVSL is CHARACTER*1 = 'N': do not compute the left Schur vectors; = 'V': compute the left Schur vectors (returned in VSL).``` [in] JOBVSR ``` JOBVSR is CHARACTER*1 = 'N': do not compute the right Schur vectors; = 'V': compute the right Schur vectors (returned in VSR).``` [in] N ``` N is INTEGER The order of the matrices A, B, VSL, and VSR. N >= 0.``` [in,out] A ``` A is DOUBLE PRECISION array, dimension (LDA, N) On entry, the matrix A. On exit, the upper quasi-triangular matrix S from the generalized real Schur factorization.``` [in] LDA ``` LDA is INTEGER The leading dimension of A. LDA >= max(1,N).``` [in,out] B ``` B is DOUBLE PRECISION array, dimension (LDB, N) On entry, the matrix B. On exit, the upper triangular matrix T from the generalized real Schur factorization.``` [in] LDB ``` LDB is INTEGER The leading dimension of B. LDB >= max(1,N).``` [out] ALPHAR ``` ALPHAR is DOUBLE PRECISION array, dimension (N) The real parts of each scalar alpha defining an eigenvalue of GNEP.``` [out] ALPHAI ``` ALPHAI is DOUBLE PRECISION array, dimension (N) The imaginary parts of each scalar alpha defining an eigenvalue of GNEP. If ALPHAI(j) is zero, then the j-th eigenvalue is real; if positive, then the j-th and (j+1)-st eigenvalues are a complex conjugate pair, with ALPHAI(j+1) = -ALPHAI(j).``` [out] BETA ``` BETA is DOUBLE PRECISION array, dimension (N) The scalars beta that define the eigenvalues of GNEP. Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and beta = BETA(j) represent the j-th eigenvalue of the matrix pair (A,B), in one of the forms lambda = alpha/beta or mu = beta/alpha. Since either lambda or mu may overflow, they should not, in general, be computed.``` [out] VSL ``` VSL is DOUBLE PRECISION array, dimension (LDVSL,N) If JOBVSL = 'V', the matrix of left Schur vectors Q. Not referenced if JOBVSL = 'N'.``` [in] LDVSL ``` LDVSL is INTEGER The leading dimension of the matrix VSL. LDVSL >=1, and if JOBVSL = 'V', LDVSL >= N.``` [out] VSR ``` VSR is DOUBLE PRECISION array, dimension (LDVSR,N) If JOBVSR = 'V', the matrix of right Schur vectors Z. Not referenced if JOBVSR = 'N'.``` [in] LDVSR ``` LDVSR is INTEGER The leading dimension of the matrix VSR. LDVSR >= 1, and if JOBVSR = 'V', LDVSR >= N.``` [out] WORK ``` WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK(1) returns the optimal LWORK.``` [in] LWORK ``` LWORK is INTEGER The dimension of the array WORK. LWORK >= max(1,4*N). For good performance, LWORK must generally be larger. To compute the optimal value of LWORK, call ILAENV to get blocksizes (for DGEQRF, DORMQR, and DORGQR.) Then compute: NB -- MAX of the blocksizes for DGEQRF, DORMQR, and DORGQR The optimal LWORK is 2*N + N*(NB+1). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.``` [out] INFO ``` INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value. = 1,...,N: The QZ iteration failed. (A,B) are not in Schur form, but ALPHAR(j), ALPHAI(j), and BETA(j) should be correct for j=INFO+1,...,N. > N: errors that usually indicate LAPACK problems: =N+1: error return from DGGBAL =N+2: error return from DGEQRF =N+3: error return from DORMQR =N+4: error return from DORGQR =N+5: error return from DGGHRD =N+6: error return from DHGEQZ (other than failed iteration) =N+7: error return from DGGBAK (computing VSL) =N+8: error return from DGGBAK (computing VSR) =N+9: error return from DLASCL (various places)```

Definition at line 224 of file dgegs.f.

227 *
228 * -- LAPACK driver routine --
229 * -- LAPACK is a software package provided by Univ. of Tennessee, --
230 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
231 *
232 * .. Scalar Arguments ..
233  CHARACTER JOBVSL, JOBVSR
234  INTEGER INFO, LDA, LDB, LDVSL, LDVSR, LWORK, N
235 * ..
236 * .. Array Arguments ..
237  DOUBLE PRECISION A( LDA, * ), ALPHAI( * ), ALPHAR( * ),
238  \$ B( LDB, * ), BETA( * ), VSL( LDVSL, * ),
239  \$ VSR( LDVSR, * ), WORK( * )
240 * ..
241 *
242 * =====================================================================
243 *
244 * .. Parameters ..
245  DOUBLE PRECISION ZERO, ONE
246  parameter( zero = 0.0d0, one = 1.0d0 )
247 * ..
248 * .. Local Scalars ..
249  LOGICAL ILASCL, ILBSCL, ILVSL, ILVSR, LQUERY
250  INTEGER ICOLS, IHI, IINFO, IJOBVL, IJOBVR, ILEFT, ILO,
251  \$ IRIGHT, IROWS, ITAU, IWORK, LOPT, LWKMIN,
252  \$ LWKOPT, NB, NB1, NB2, NB3
253  DOUBLE PRECISION ANRM, ANRMTO, BIGNUM, BNRM, BNRMTO, EPS,
254  \$ SAFMIN, SMLNUM
255 * ..
256 * .. External Subroutines ..
257  EXTERNAL dgeqrf, dggbak, dggbal, dgghrd, dhgeqz, dlacpy,
259 * ..
260 * .. External Functions ..
261  LOGICAL LSAME
262  INTEGER ILAENV
263  DOUBLE PRECISION DLAMCH, DLANGE
264  EXTERNAL lsame, ilaenv, dlamch, dlange
265 * ..
266 * .. Intrinsic Functions ..
267  INTRINSIC int, max
268 * ..
269 * .. Executable Statements ..
270 *
271 * Decode the input arguments
272 *
273  IF( lsame( jobvsl, 'N' ) ) THEN
274  ijobvl = 1
275  ilvsl = .false.
276  ELSE IF( lsame( jobvsl, 'V' ) ) THEN
277  ijobvl = 2
278  ilvsl = .true.
279  ELSE
280  ijobvl = -1
281  ilvsl = .false.
282  END IF
283 *
284  IF( lsame( jobvsr, 'N' ) ) THEN
285  ijobvr = 1
286  ilvsr = .false.
287  ELSE IF( lsame( jobvsr, 'V' ) ) THEN
288  ijobvr = 2
289  ilvsr = .true.
290  ELSE
291  ijobvr = -1
292  ilvsr = .false.
293  END IF
294 *
295 * Test the input arguments
296 *
297  lwkmin = max( 4*n, 1 )
298  lwkopt = lwkmin
299  work( 1 ) = lwkopt
300  lquery = ( lwork.EQ.-1 )
301  info = 0
302  IF( ijobvl.LE.0 ) THEN
303  info = -1
304  ELSE IF( ijobvr.LE.0 ) THEN
305  info = -2
306  ELSE IF( n.LT.0 ) THEN
307  info = -3
308  ELSE IF( lda.LT.max( 1, n ) ) THEN
309  info = -5
310  ELSE IF( ldb.LT.max( 1, n ) ) THEN
311  info = -7
312  ELSE IF( ldvsl.LT.1 .OR. ( ilvsl .AND. ldvsl.LT.n ) ) THEN
313  info = -12
314  ELSE IF( ldvsr.LT.1 .OR. ( ilvsr .AND. ldvsr.LT.n ) ) THEN
315  info = -14
316  ELSE IF( lwork.LT.lwkmin .AND. .NOT.lquery ) THEN
317  info = -16
318  END IF
319 *
320  IF( info.EQ.0 ) THEN
321  nb1 = ilaenv( 1, 'DGEQRF', ' ', n, n, -1, -1 )
322  nb2 = ilaenv( 1, 'DORMQR', ' ', n, n, n, -1 )
323  nb3 = ilaenv( 1, 'DORGQR', ' ', n, n, n, -1 )
324  nb = max( nb1, nb2, nb3 )
325  lopt = 2*n + n*( nb+1 )
326  work( 1 ) = lopt
327  END IF
328 *
329  IF( info.NE.0 ) THEN
330  CALL xerbla( 'DGEGS ', -info )
331  RETURN
332  ELSE IF( lquery ) THEN
333  RETURN
334  END IF
335 *
336 * Quick return if possible
337 *
338  IF( n.EQ.0 )
339  \$ RETURN
340 *
341 * Get machine constants
342 *
343  eps = dlamch( 'E' )*dlamch( 'B' )
344  safmin = dlamch( 'S' )
345  smlnum = n*safmin / eps
346  bignum = one / smlnum
347 *
348 * Scale A if max element outside range [SMLNUM,BIGNUM]
349 *
350  anrm = dlange( 'M', n, n, a, lda, work )
351  ilascl = .false.
352  IF( anrm.GT.zero .AND. anrm.LT.smlnum ) THEN
353  anrmto = smlnum
354  ilascl = .true.
355  ELSE IF( anrm.GT.bignum ) THEN
356  anrmto = bignum
357  ilascl = .true.
358  END IF
359 *
360  IF( ilascl ) THEN
361  CALL dlascl( 'G', -1, -1, anrm, anrmto, n, n, a, lda, iinfo )
362  IF( iinfo.NE.0 ) THEN
363  info = n + 9
364  RETURN
365  END IF
366  END IF
367 *
368 * Scale B if max element outside range [SMLNUM,BIGNUM]
369 *
370  bnrm = dlange( 'M', n, n, b, ldb, work )
371  ilbscl = .false.
372  IF( bnrm.GT.zero .AND. bnrm.LT.smlnum ) THEN
373  bnrmto = smlnum
374  ilbscl = .true.
375  ELSE IF( bnrm.GT.bignum ) THEN
376  bnrmto = bignum
377  ilbscl = .true.
378  END IF
379 *
380  IF( ilbscl ) THEN
381  CALL dlascl( 'G', -1, -1, bnrm, bnrmto, n, n, b, ldb, iinfo )
382  IF( iinfo.NE.0 ) THEN
383  info = n + 9
384  RETURN
385  END IF
386  END IF
387 *
388 * Permute the matrix to make it more nearly triangular
389 * Workspace layout: (2*N words -- "work..." not actually used)
390 * left_permutation, right_permutation, work...
391 *
392  ileft = 1
393  iright = n + 1
394  iwork = iright + n
395  CALL dggbal( 'P', n, a, lda, b, ldb, ilo, ihi, work( ileft ),
396  \$ work( iright ), work( iwork ), iinfo )
397  IF( iinfo.NE.0 ) THEN
398  info = n + 1
399  GO TO 10
400  END IF
401 *
402 * Reduce B to triangular form, and initialize VSL and/or VSR
403 * Workspace layout: ("work..." must have at least N words)
404 * left_permutation, right_permutation, tau, work...
405 *
406  irows = ihi + 1 - ilo
407  icols = n + 1 - ilo
408  itau = iwork
409  iwork = itau + irows
410  CALL dgeqrf( irows, icols, b( ilo, ilo ), ldb, work( itau ),
411  \$ work( iwork ), lwork+1-iwork, iinfo )
412  IF( iinfo.GE.0 )
413  \$ lwkopt = max( lwkopt, int( work( iwork ) )+iwork-1 )
414  IF( iinfo.NE.0 ) THEN
415  info = n + 2
416  GO TO 10
417  END IF
418 *
419  CALL dormqr( 'L', 'T', irows, icols, irows, b( ilo, ilo ), ldb,
420  \$ work( itau ), a( ilo, ilo ), lda, work( iwork ),
421  \$ lwork+1-iwork, iinfo )
422  IF( iinfo.GE.0 )
423  \$ lwkopt = max( lwkopt, int( work( iwork ) )+iwork-1 )
424  IF( iinfo.NE.0 ) THEN
425  info = n + 3
426  GO TO 10
427  END IF
428 *
429  IF( ilvsl ) THEN
430  CALL dlaset( 'Full', n, n, zero, one, vsl, ldvsl )
431  CALL dlacpy( 'L', irows-1, irows-1, b( ilo+1, ilo ), ldb,
432  \$ vsl( ilo+1, ilo ), ldvsl )
433  CALL dorgqr( irows, irows, irows, vsl( ilo, ilo ), ldvsl,
434  \$ work( itau ), work( iwork ), lwork+1-iwork,
435  \$ iinfo )
436  IF( iinfo.GE.0 )
437  \$ lwkopt = max( lwkopt, int( work( iwork ) )+iwork-1 )
438  IF( iinfo.NE.0 ) THEN
439  info = n + 4
440  GO TO 10
441  END IF
442  END IF
443 *
444  IF( ilvsr )
445  \$ CALL dlaset( 'Full', n, n, zero, one, vsr, ldvsr )
446 *
447 * Reduce to generalized Hessenberg form
448 *
449  CALL dgghrd( jobvsl, jobvsr, n, ilo, ihi, a, lda, b, ldb, vsl,
450  \$ ldvsl, vsr, ldvsr, iinfo )
451  IF( iinfo.NE.0 ) THEN
452  info = n + 5
453  GO TO 10
454  END IF
455 *
456 * Perform QZ algorithm, computing Schur vectors if desired
457 * Workspace layout: ("work..." must have at least 1 word)
458 * left_permutation, right_permutation, work...
459 *
460  iwork = itau
461  CALL dhgeqz( 'S', jobvsl, jobvsr, n, ilo, ihi, a, lda, b, ldb,
462  \$ alphar, alphai, beta, vsl, ldvsl, vsr, ldvsr,
463  \$ work( iwork ), lwork+1-iwork, iinfo )
464  IF( iinfo.GE.0 )
465  \$ lwkopt = max( lwkopt, int( work( iwork ) )+iwork-1 )
466  IF( iinfo.NE.0 ) THEN
467  IF( iinfo.GT.0 .AND. iinfo.LE.n ) THEN
468  info = iinfo
469  ELSE IF( iinfo.GT.n .AND. iinfo.LE.2*n ) THEN
470  info = iinfo - n
471  ELSE
472  info = n + 6
473  END IF
474  GO TO 10
475  END IF
476 *
477 * Apply permutation to VSL and VSR
478 *
479  IF( ilvsl ) THEN
480  CALL dggbak( 'P', 'L', n, ilo, ihi, work( ileft ),
481  \$ work( iright ), n, vsl, ldvsl, iinfo )
482  IF( iinfo.NE.0 ) THEN
483  info = n + 7
484  GO TO 10
485  END IF
486  END IF
487  IF( ilvsr ) THEN
488  CALL dggbak( 'P', 'R', n, ilo, ihi, work( ileft ),
489  \$ work( iright ), n, vsr, ldvsr, iinfo )
490  IF( iinfo.NE.0 ) THEN
491  info = n + 8
492  GO TO 10
493  END IF
494  END IF
495 *
496 * Undo scaling
497 *
498  IF( ilascl ) THEN
499  CALL dlascl( 'H', -1, -1, anrmto, anrm, n, n, a, lda, iinfo )
500  IF( iinfo.NE.0 ) THEN
501  info = n + 9
502  RETURN
503  END IF
504  CALL dlascl( 'G', -1, -1, anrmto, anrm, n, 1, alphar, n,
505  \$ iinfo )
506  IF( iinfo.NE.0 ) THEN
507  info = n + 9
508  RETURN
509  END IF
510  CALL dlascl( 'G', -1, -1, anrmto, anrm, n, 1, alphai, n,
511  \$ iinfo )
512  IF( iinfo.NE.0 ) THEN
513  info = n + 9
514  RETURN
515  END IF
516  END IF
517 *
518  IF( ilbscl ) THEN
519  CALL dlascl( 'U', -1, -1, bnrmto, bnrm, n, n, b, ldb, iinfo )
520  IF( iinfo.NE.0 ) THEN
521  info = n + 9
522  RETURN
523  END IF
524  CALL dlascl( 'G', -1, -1, bnrmto, bnrm, n, 1, beta, n, iinfo )
525  IF( iinfo.NE.0 ) THEN
526  info = n + 9
527  RETURN
528  END IF
529  END IF
530 *
531  10 CONTINUE
532  work( 1 ) = lwkopt
533 *
534  RETURN
535 *
536 * End of DGEGS
537 *
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:69
subroutine dlascl(TYPE, KL, KU, CFROM, CTO, M, N, A, LDA, INFO)
DLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.
Definition: dlascl.f:143
subroutine dlacpy(UPLO, M, N, A, LDA, B, LDB)
DLACPY copies all or part of one two-dimensional array to another.
Definition: dlacpy.f:103
subroutine dlaset(UPLO, M, N, ALPHA, BETA, A, LDA)
DLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition: dlaset.f:110
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: ilaenv.f:162
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine dggbak(JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V, LDV, INFO)
DGGBAK
Definition: dggbak.f:147
subroutine dggbal(JOB, N, A, LDA, B, LDB, ILO, IHI, LSCALE, RSCALE, WORK, INFO)
DGGBAL
Definition: dggbal.f:177
double precision function dlange(NORM, M, N, A, LDA, WORK)
DLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition: dlange.f:114
subroutine dhgeqz(JOB, COMPQ, COMPZ, N, ILO, IHI, H, LDH, T, LDT, ALPHAR, ALPHAI, BETA, Q, LDQ, Z, LDZ, WORK, LWORK, INFO)
DHGEQZ
Definition: dhgeqz.f:304
subroutine dgeqrf(M, N, A, LDA, TAU, WORK, LWORK, INFO)
DGEQRF
Definition: dgeqrf.f:145
subroutine dorgqr(M, N, K, A, LDA, TAU, WORK, LWORK, INFO)
DORGQR
Definition: dorgqr.f:128
subroutine dgghrd(COMPQ, COMPZ, N, ILO, IHI, A, LDA, B, LDB, Q, LDQ, Z, LDZ, INFO)
DGGHRD
Definition: dgghrd.f:207
subroutine dormqr(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
DORMQR
Definition: dormqr.f:167
Here is the call graph for this function: