Previous: cggqrf Up: ../lapack-c.html Next: cggsvd


cggrqf


 NAME
      CGGRQF - compute a generalized RQ factorization of an M-by-N
      matrix A and a P-by-N matrix B

 SYNOPSIS
      SUBROUTINE CGGRQF( M, P, N, A, LDA, TAUA, B, LDB, TAUB,
                         WORK, LWORK, INFO )

          INTEGER        INFO, LDA, LDB, LWORK, M, N, P

          COMPLEX        A( LDA, * ), B( LDB, * ), TAUA( * ),
                         TAUB( * ), WORK( * )

 PURPOSE
      CGGRQF computes a generalized RQ factorization of an M-by-N
      matrix A and a P-by-N matrix B:

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

      where Q is an M-by-M unitary matrix, and Z is an N-by-N uni-
      tary matrix.  R and T assume one of the forms:

      if M <= N,                   or if M > N

           R = ( 0  R12 ) M,            R = ( R11 ) M-N
                N-M  M                      ( R21 ) N
                                               N
      where R12 or R21 is upper triangular, and

      if P >= N,                   or if P < N

           T = ( T11 ) N                T = ( T11  T12 ) P
               (  0  ) P-N                     P   N-P
                  N

      where T11 is an upper triangular matrix.

      In particular, if B is square and nonsingular, the GRQ fac-
      torization of A and B implicitly gives the RQ factorization
      of matrix A*inv(B):

                          A*inv(B) = (R*inv(T))*Z'

      where inv(B) denotes the inverse of the matrix B, and Z'
      denotes the conjugate transpose of the matrix Z.

 ARGUMENTS
      M       (input) INTEGER
              The number of rows of the matrix A.  M >= 0.

      P       (input) INTEGER

              The number of rows of the matrix B.  P >= 0.

      N       (input) INTEGER
              The number of columns of the matrices A and B. N >=
              0.

      A       (input/output) COMPLEX array, dimension (LDA,N)
              On entry, the M-by-N matrix A.  On exit, if M <= N,
              the upper triangle of the subarray A(1:M,N-M+1:N)
              contains the M-by-M upper triangular matrix R; if M
              > N, the elements on and above the (M-N)-th subdiag-
              onal contain the M-by-N upper trapezoidal matrix R;
              the remaining elements, with the array TAUA,
              represent the unitary matrix Q as a product of ele-
              mentary reflectors (see Further Details).

      LDA     (input) INTEGER
              The leading dimension of the array A. LDA >=
              max(1,M).

      TAUA    (output) COMPLEX array, dimension (min(M,N))
              The scalar factors of the elementary reflectors (see
              Further Details).

      B       (input/output) COMPLEX array, dimension (LDB,N)
              On entry, the P-by-N matrix B.  On exit, the ele-
              ments on and above the diagonal of the array contain
              the MIN(P,N)-by-N upper trapezoidal matrix T (T is
              upper triangular if P >= N); the elements below the
              diagonal, with the array TAUB, represent the unitary
              matrix Z as a product of elementary reflectors (see
              Further Details).  LDB     (input) INTEGER The lead-
              ing dimension of the array B. LDB >= MAX(1,P).

      TAUB    (output) COMPLEX array, dimension (MIN(P,N))
              The scalar factors of the elementary reflectors (see
              Further Details).

      WORK    (workspace) COMPLEX array, dimension (LWORK)
              On exit, if INFO = 0, WORK(1) returns the optimal
              LWORK.

      LWORK   (input) INTEGER
              The dimension of the array WORK. LWORK >=
              MAX(1,N,M,P).  For optimum performance LWORK >=
              MAX(1,N,M,P)*MAX(NB1,NB2,NB3), where NB1 is the
              optimal blocksize for the RQ factorization of the
              M-by-N matrix A.  NB2 is the optimal blocksize for
              the QR factorization of the P-by-N matrix B.  NB3 is
              the optimal blocksize for CUNMRQ.

      INFO    (output) INTEGER

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

 FURTHER DETAILS
      The matrix Q is represented as a product of elementary
      reflectors

         Q = H(1) H(2) . . . H(k), where k = min(M,N).

      Each H(i) has the form

         H(i) = I - taub * v * v'

      where taub is a complex scalar, and v is a complex vector
      with v(N-k+i+1:N) = 0 and v(N-k+i) = 1; v(1:N-k+i-1) is
      stored on exit in A(M-k+i,1:n-k+i-1), and taub in TAUA(i).
      To form Q explicitly, use LAPACK subroutine CUNGRQ.
      To use Q to update another matrix, use LAPACK subroutine
      CUNMRQ.

      The matrix Z is represented as a product of elementary
      reflectors

         Z = H(1) H(2) . . . H(k), where k = min(P,N).

      Each H(i) has the form

         H(i) = I - taua * v * v'

      where taua is a complex scalar, and v is a complex vector
      with v(1:i-1) = 0 and v(i) = 1; v(i+1:M) is stored on exit
      in B(i+1:P,i), and taua in TAUB(i).
      To form Z explicitly, use LAPACK subroutine CUNGQR.
      To use Z to update another matrix, use LAPACK subroutine
      CUNMQR.