ORMBR - 5.2 English - 68552

Apply Q or Q’ from bidiagonal reduction.

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
       elementary 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).

Parameters:

• vect – [in]

  vect is char*

  = ‘Q’: apply Q or Q**T;

  = ‘P’: apply P or P**T.

• side – [in]

  side is char*

  = ‘L’: apply Q, Q**T, P or P**T from the Left;

  = ‘R’: apply Q, Q**T, P or P**T from the Right.

• trans – [in]

  trans is char*

  = ‘N’: No transpose, apply Q or P;

  = ‘T’: Transpose, apply Q**T or P**T.

• m – [in]

  m is integer*

  The number of rows of the matrix c. m >= 0.

• n – [in]

  n is integer*

  The number of columns of the matrix c. n >= 0.

• k – [in]

  k is integer*

  If vect = ‘Q’, the number of columns in the original matrix reduced by SGEBRD.

  If vect = ‘P’, the number of rows in the original matrix reduced by SGEBRD.

  k >= 0.

• a – [in]

  a is float/double 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 – [in]

  lda is integer*

  The leading dimension of the array a.

  If vect = ‘Q’, lda >= fla_max(1,nq);

  if vect = ‘P’, lda >= fla_max(1,min(nq,k)).

• tau – [in]

  tau is float/double array, dimension (min(nq,k))

  tau(i) must contain the scalar factor of the elementary reflector H(i) or G(i) which determines Q or P, as returned by SGEBRD in the array argument tauq or taup.

• c – [inout]

  c is float/double 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 – [in]

  ldc is integer*

  The leading dimension of the array c. ldc >= fla_max(1,m).

• WORK – [out]

  WORK is REAL array, dimension (MAX(1,LWORK))

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

• LWORK – [in]

  LWORK is INTEGER

  The dimension of the array WORK.

  If SIDE = ‘L’, LWORK >= fla_max(1,N);

  if SIDE = ‘R’, LWORK >= fla_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 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 – [out]

  INFO is INTEGER

  = 0: successful exit

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