Loading...
Searching...
No Matches

## stgex2()

subroutine stgex2 | ( | logical | wantq,
|  | logical | wantz,
|  | integer | n,
|  | real, dimension( lda, * ) | a,
|  | integer | lda,
|  | real, dimension( ldb, * ) | b,
|  | integer | ldb,
|  | real, dimension( ldq, * ) | q,
|  | integer | ldq,
|  | real, dimension( ldz, * ) | z,
|  | integer | ldz,
|  | integer | j1,
|  | integer | n1,
|  | integer | n2,
|  | real, dimension( * ) | work,
|  | integer | lwork,
|  | integer | info )

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

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

Purpose:

      !>
      !> STGEX2 swaps adjacent diagonal blocks (A11, B11) and (A22, B22)
      !> of size 1-by-1 or 2-by-2 in an upper (quasi) triangular matrix pair
      !> (A, B) by an orthogonal equivalence transformation.
      !>
      !> (A, B) must be in generalized real Schur canonical form (as returned
      !> by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2
      !> diagonal blocks. B is upper triangular.
      !>
      !> Optionally, the matrices Q and Z of generalized Schur vectors are
      !> updated.
      !>
      !>        Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T
      !>        Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T
      !>
      !>

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 REAL array, dimension (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 REAL array, dimension (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 REAL array, dimension (LDQ,N)
      !>          On entry, if WANTQ = .TRUE., the orthogonal 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 REAL array, dimension (LDZ,N)
      !>          On entry, if WANTZ =.TRUE., the orthogonal 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). 1 <= J1 <= N.
      !>

  [in]

  N1

      !>          N1 is INTEGER
      !>          The order of the first block (A11, B11). N1 = 0, 1 or 2.
      !>

  [in]

  N2

      !>          N2 is INTEGER
      !>          The order of the second block (A22, B22). N2 = 0, 1 or 2.
      !>

  [out]

  WORK

      !>          WORK is REAL array, dimension (MAX(1,LWORK)).
      !>

  [in]

  LWORK

      !>          LWORK is INTEGER
      !>          The dimension of the array WORK.
      !>          LWORK >=  MAX( N*(N2+N1), (N2+N1)*(N2+N1)*2 )
      !>

  [out]

  INFO

      !>          INFO is INTEGER
      !>            =0: Successful exit
      !>            >0: If INFO = 1, the transformed matrix (A, B) would be
      !>                too far from generalized Schur form; the blocks are
      !>                not swapped and (A, B) and (Q, Z) are unchanged.
      !>                The problem of swapping is too ill-conditioned.
      !>            <0: If INFO = -16: LWORK is too small. Appropriate value
      !>                for LWORK is returned in WORK(1).
      !>

Author
  Univ. of Tennessee
  Univ. of California Berkeley
  Univ. of Colorado Denver
  NAG Ltd.

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.
      !>