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


SYNOPSIS

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

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

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


PURPOSE

       SGGRQF 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  N-by-N  orthogonal matrix, Z is a P-by-P
       orthogonal matrix, and R and T assume one of the forms:

       if M <= N,  R = ( 0  R12 ) M,   or if M > N,  R = ( R11  )
       M-N,
                        N-M   M                           ( R21 )
       N
                                                            N

       where R12 or R21 is upper triangular, and

       if P >= N,  T = ( T11 ) N  ,   or if P < N,   T  =  (  T11
       T12 ) P,
                       (  0  ) P-N                         P   N-
       P
                          N

       where T11 is upper triangular.

       In particular, if B is square  and  nonsingular,  the  GRQ
       factorization  of  A and B implicitly gives the RQ factor­
       ization of A*inv(B):

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

       where inv(B) denotes the inverse of the matrix B,  and  Z'
       denotes the 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.

               The  number  of columns of the matrices A and B. N
               >= 0.

       A       (input/output) REAL 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 subdiagonal contain the M-by-N upper  trape­
               zoidal  matrix R; the remaining elements, with the
               array TAUA, represent the orthogonal matrix Q as a
               product  of  elementary  reflectors  (see  Further
               Details).

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

       TAUA    (output) REAL array, dimension (min(M,N))
               The  scalar  factors  of the elementary reflectors
               which represent the orthogonal matrix Q (see  Fur­
               ther Details).  B       (input/output) REAL array,
               dimension (LDB,N) On entry, the P-by-N  matrix  B.
               On exit, the elements on and above the diagonal of
               the array contain the min(P,N)-by-N  upper  trape­
               zoidal matrix T (T is upper triangular if P >= N);
               the elements below the diagonal,  with  the  array
               TAUB, represent the orthogonal matrix Z as a prod­
               uct  of   elementary   reflectors   (see   Further
               Details).   LDB      (input)  INTEGER  The leading
               dimension of the array B. LDB >= max(1,P).

       TAUB    (output) REAL array, dimension (min(P,N))
               The scalar factors of  the  elementary  reflectors
               which  represent the orthogonal matrix Z (see Fur­
               ther Details).   WORK     (workspace/output)  REAL
               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(N,M,P)*max(NB1,NB2,NB3),  where  NB1  is   the
               optimal  blocksize  for the RQ factorization of an
               M-by-N matrix, NB2 is the  optimal  blocksize  for
               the  QR  factorization of a P-by-N matrix, and NB3
               is the optimal blocksize for a call of SORMRQ.

               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.

               = 0:  successful exit
               < 0:  if INF0= -i, the i-th argument had an  ille­
               gal 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 - taua * v * v'

       where taua is a real scalar, and v is a real 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 taua in TAUA(i).
       To form Q explicitly, use LAPACK subroutine SORGRQ.
       To  use  Q to update another matrix, use LAPACK subroutine
       SORMRQ.

       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 - taub * v * v'

       where taub is a real scalar, and v is a real vector with
       v(1:i-1)  =  0 and v(i) = 1; v(i+1:p) is stored on exit in
       B(i+1:p,i), and taub in TAUB(i).
       To form Z explicitly, use LAPACK subroutine SORGQR.
       To use Z to update another matrix, use  LAPACK  subroutine
       SORMQR.


Man(1) output converted with man2html