SRC/stgexc.f(3)

NAME
SRC/stgexc.f

SYNOPSIS

  Functions/Subroutines
subroutine stgexc (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info)
STGEXC

Function/Subroutine Documentation

  subroutine stgexc (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 ifst, integer ilst, real, dimension( * ) work, integer lwork, integer info)

STGEXC

Purpose:

    !>
    !> STGEXC reorders the generalized real Schur decomposition of a real
    !> matrix pair (A,B) using an orthogonal equivalence transformation
    !>
    !>                (A, B) = Q * (A, B) * Z**T,
    !>
    !> so that the diagonal block of (A, B) with row index IFST is moved
    !> to row ILST.
    !>
    !> (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
    WANTQ

    !>          WANTQ is LOGICAL
    !>          .TRUE. : update the left transformation matrix Q;
    !>          .FALSE.: do not update Q.
    !>

    WANTZ

    !>          WANTZ is LOGICAL
    !>          .TRUE. : update the right transformation matrix Z;
    !>          .FALSE.: do not update Z.
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrices A and B. N >= 0.
    !>

    A

    !>          A is REAL array, dimension (LDA,N)
    !>          On entry, the matrix A in generalized real Schur canonical
    !>          form.
    !>          On exit, the updated matrix A, again in generalized
    !>          real Schur canonical form.
    !>

    LDA

    !>          LDA is INTEGER
    !>          The leading dimension of the array A. LDA >= max(1,N).
    !>

    B

    !>          B is REAL array, dimension (LDB,N)
    !>          On entry, the matrix B in generalized real Schur canonical
    !>          form (A,B).
    !>          On exit, the updated matrix B, again in generalized
    !>          real Schur canonical form (A,B).
    !>

    LDB

    !>          LDB is INTEGER
    !>          The leading dimension of the array B. LDB >= max(1,N).
    !>

    Q

    !>          Q is REAL array, dimension (LDQ,N)
    !>          On entry, if WANTQ = .TRUE., the orthogonal matrix Q.
    !>          On exit, the updated matrix Q.
    !>          If WANTQ = .FALSE., Q is not referenced.
    !>

    LDQ

    !>          LDQ is INTEGER
    !>          The leading dimension of the array Q. LDQ >= 1.
    !>          If WANTQ = .TRUE., LDQ >= N.
    !>

    Z

    !>          Z is REAL array, dimension (LDZ,N)
    !>          On entry, if WANTZ = .TRUE., the orthogonal matrix Z.
    !>          On exit, the updated matrix Z.
    !>          If WANTZ = .FALSE., Z is not referenced.
    !>

    LDZ

    !>          LDZ is INTEGER
    !>          The leading dimension of the array Z. LDZ >= 1.
    !>          If WANTZ = .TRUE., LDZ >= N.
    !>

    IFST

    !>          IFST is INTEGER
    !>

    ILST

    !>          ILST is INTEGER
    !>          Specify the reordering of the diagonal blocks of (A, B).
    !>          The block with row index IFST is moved to row ILST, by a
    !>          sequence of swapping between adjacent blocks.
    !>          On exit, if IFST pointed on entry to the second row of
    !>          a 2-by-2 block, it is changed to point to the first row;
    !>          ILST always points to the first row of the block in its
    !>          final position (which may differ from its input value by
    !>          +1 or -1). 1 <= IFST, ILST <= N.
    !>

    WORK

    !>          WORK is REAL array, dimension (MAX(1,LWORK))
    !>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
    !>

    LWORK

    !>          LWORK is INTEGER
    !>          The dimension of the array WORK.
    !>          LWORK >= 1 when N <= 1, otherwise LWORK >= 4*N + 16.
    !>
    !>          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.
    !>

    INFO

    !>          INFO is INTEGER
    !>           =0:  successful exit.
    !>           <0:  if INFO = -i, the i-th argument had an illegal value.
    !>           =1:  The transformed matrix pair (A, B) would be too far
    !>                from generalized Schur form; the problem is ill-
    !>                conditioned. (A, B) may have been partially reordered,
    !>                and ILST points to the first row of the current
    !>                position of the block being moved.
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

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

Definition at line 218 of file stgexc.f.

Author

Generated automatically by Doxygen for LAPACK from the source code.