SORMBR - VECT = 'Q', SORMBR overwrites the general real M-
       by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'


SYNOPSIS

       SUBROUTINE SORMBR( VECT, SIDE, TRANS, M,  N,  K,  A,  LDA,
                          TAU, C, LDC, WORK, LWORK, INFO )

           CHARACTER      SIDE, TRANS, VECT

           INTEGER        INFO, K, LDA, LDC, LWORK, M, N

           REAL           A(  LDA,  *  ),  C( LDC, * ), TAU( * ),
                          WORK( * )


PURPOSE

       If VECT = 'Q', SORMBR overwrites the general  real  M-by-N
       matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C *
       Q TRANS = 'T':      Q**T * C       C * Q**T

       If VECT = 'P', SORMBR overwrites the general  real  M-by-N
       matrix C with
                       SIDE = 'L'     SIDE = 'R'
       TRANS = 'N':      P * C          C * P
       TRANS = 'T':      P**T * C       C * P**T

       Here  Q and P**T are the orthogonal matrices determined by
       SGEBRD when reducing a real matrix A to bidiagonal form: A
       = Q * B * P**T. Q and P**T are defined as products of ele­
       mentary reflectors H(i) and G(i) respectively.

       Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq
       is  the  order  of the orthogonal matrix Q or P**T that is
       applied.

       If VECT = 'Q', A  is  assumed  to  have  been  an  NQ-by-K
       matrix: if nq >= k, Q = H(1) H(2) . . . H(k);
       if nq < k, Q = H(1) H(2) . . . H(nq-1).

       If VECT = 'P', A is assumed to have been a K-by-NQ matrix:
       if k < nq, P = G(1) G(2) . . . G(k);
       if k >= nq, P = G(1) G(2) . . . G(nq-1).


ARGUMENTS

       VECT    (input) CHARACTER*1
               = 'Q': apply Q or Q**T;
               = 'P': apply P or P**T.

       SIDE    (input) CHARACTER*1
               = 'L': apply Q, Q**T, P or P**T from the Left;
               = 'R': apply Q, Q**T, P or P**T from the Right.

               = 'N':  No transpose, apply Q  or P;
               = 'T':  Transpose, apply Q**T or P**T.

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

       N       (input) INTEGER
               The number of columns of the matrix C. N >= 0.

       K       (input) INTEGER
               If VECT = 'Q', the number of columns in the origi­
               nal  matrix reduced by SGEBRD.  If VECT = 'P', the
               number of rows in the original matrix  reduced  by
               SGEBRD.  K >= 0.

       A       (input) REAL array, dimension
               (LDA,min(nq,K))  if  VECT = 'Q' (LDA,nq)        if
               VECT = 'P' The vectors which define the elementary
               reflectors H(i) and G(i), whose products determine
               the matrices Q and P, as returned by SGEBRD.

       LDA     (input) INTEGER
               The leading dimension of the array A.  If  VECT  =
               'Q',  LDA  >=  max(1,nq);  if  VECT  = 'P', LDA >=
               max(1,min(nq,K)).

       TAU     (input) REAL array, dimension (min(nq,K))
               TAU(i) must contain the scalar factor of the  ele­
               mentary  reflector H(i) or G(i) which determines Q
               or P, as returned by SGEBRD in the array  argument
               TAUQ or TAUP.

       C       (input/output) REAL array, dimension (LDC,N)
               On  entry,  the  M-by-N  matrix  C.  On exit, C is
               overwritten by Q*C or Q**T*C or C*Q**T or  C*Q  or
               P*C or P**T*C or C*P or C*P**T.

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

       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.  If SIDE = 'L',
               LWORK  >=  max(1,N);  if  SIDE  =  'R',  LWORK  >=
               max(1,M).   For  optimum performance LWORK >= N*NB
               if SIDE = 'L', and LWORK >= M*NB if  SIDE  =  'R',
               where NB is the optimal blocksize.

               If  LWORK = -1, then a workspace query is assumed;

               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    (output) INTEGER
               = 0:  successful exit
               < 0:  if INFO = -i, the i-th argument had an ille­
               gal value


Man(1) output converted with man2html