Loading...
Searching...
No Matches

## dgghrd()

subroutine dgghrd | ( | character | compq,
|  | character | compz,
|  | integer | n,
|  | integer | ilo,
|  | integer | ihi,
|  | double precision, dimension( lda, * ) | a,
|  | integer | lda,
|  | double precision, dimension( ldb, * ) | b,
|  | integer | ldb,
|  | double precision, dimension( ldq, * ) | q,
|  | integer | ldq,
|  | double precision, dimension( ldz, * ) | z,
|  | integer | ldz,
|  | integer | info )

DGGHRD

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

Purpose:

      !>
      !> DGGHRD reduces a pair of real matrices (A,B) to generalized upper
      !> Hessenberg form using orthogonal transformations, where A is a
      !> general matrix and B is upper triangular.  The form of the
      !> generalized eigenvalue problem is
      !>    A*x = lambda*B*x,
      !> and B is typically made upper triangular by computing its QR
      !> factorization and moving the orthogonal matrix Q to the left side
      !> of the equation.
      !>
      !> This subroutine simultaneously reduces A to a Hessenberg matrix H:
      !>    Q**T*A*Z = H
      !> and transforms B to another upper triangular matrix T:
      !>    Q**T*B*Z = T
      !> in order to reduce the problem to its standard form
      !>    H*y = lambda*T*y
      !> where y = Z**T*x.
      !>
      !> The orthogonal matrices Q and Z are determined as products of Givens
      !> rotations.  They may either be formed explicitly, or they may be
      !> postmultiplied into input matrices Q1 and Z1, so that
      !>
      !>      Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T
      !>
      !>      Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T
      !>
      !> If Q1 is the orthogonal matrix from the QR factorization of B in the
      !> original equation A*x = lambda*B*x, then DGGHRD reduces the original
      !> problem to generalized Hessenberg form.
      !>

Parameters

  [in]

  COMPQ

      !>          COMPQ is CHARACTER*1
      !>          = 'N': do not compute Q;
      !>          = 'I': Q is initialized to the unit matrix, and the
      !>                 orthogonal matrix Q is returned;
      !>          = 'V': Q must contain an orthogonal matrix Q1 on entry,
      !>                 and the product Q1*Q is returned.
      !>

  [in]

  COMPZ

      !>          COMPZ is CHARACTER*1
      !>          = 'N': do not compute Z;
      !>          = 'I': Z is initialized to the unit matrix, and the
      !>                 orthogonal matrix Z is returned;
      !>          = 'V': Z must contain an orthogonal matrix Z1 on entry,
      !>                 and the product Z1*Z is returned.
      !>

  [in]

  N

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

  [in]

  ILO

      !>          ILO is INTEGER
      !>

  [in]

  IHI

      !>          IHI is INTEGER
      !>
      !>          ILO and IHI mark the rows and columns of A which are to be
      !>          reduced.  It is assumed that A is already upper triangular
      !>          in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are
      !>          normally set by a previous call to DGGBAL; otherwise they
      !>          should be set to 1 and N respectively.
      !>          1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.
      !>

  [in,out]

  A

      !>          A is DOUBLE PRECISION array, dimension (LDA, N)
      !>          On entry, the N-by-N general matrix to be reduced.
      !>          On exit, the upper triangle and the first subdiagonal of A
      !>          are overwritten with the upper Hessenberg matrix H, and the
      !>          rest is set to zero.
      !>

  [in]

  LDA

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

  [in,out]

  B

      !>          B is DOUBLE PRECISION array, dimension (LDB, N)
      !>          On entry, the N-by-N upper triangular matrix B.
      !>          On exit, the upper triangular matrix T = Q**T B Z.  The
      !>          elements below the diagonal are set to zero.
      !>

  [in]

  LDB

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

  [in,out]

  Q

      !>          Q is DOUBLE PRECISION array, dimension (LDQ, N)
      !>          On entry, if COMPQ = 'V', the orthogonal matrix Q1,
      !>          typically from the QR factorization of B.
      !>          On exit, if COMPQ='I', the orthogonal matrix Q, and if
      !>          COMPQ = 'V', the product Q1*Q.
      !>          Not referenced if COMPQ='N'.
      !>

  [in]

  LDQ

      !>          LDQ is INTEGER
      !>          The leading dimension of the array Q.
      !>          LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise.
      !>

  [in,out]

  Z

      !>          Z is DOUBLE PRECISION array, dimension (LDZ, N)
      !>          On entry, if COMPZ = 'V', the orthogonal matrix Z1.
      !>          On exit, if COMPZ='I', the orthogonal matrix Z, and if
      !>          COMPZ = 'V', the product Z1*Z.
      !>          Not referenced if COMPZ='N'.
      !>

  [in]

  LDZ

      !>          LDZ is INTEGER
      !>          The leading dimension of the array Z.
      !>          LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise.
      !>

  [out]

  INFO

      !>          INFO is INTEGER
      !>          = 0:  successful exit.
      !>          < 0:  if INFO = -i, the i-th argument had an illegal value.
      !>

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

Further Details:

      !>
      !>  This routine reduces A to Hessenberg and B to triangular form by
      !>  an unblocked reduction, as described in _Matrix_Computations_,
      !>  by Golub and Van Loan (Johns Hopkins Press.)
      !>