SORGBR(l)		LAPACK routine (version	1.1)		    SORGBR(l)

NAME
  SORGBR - generate one	of the matrices	Q or P**T determined by	SGEBRD when
  reducing a real matrix A to bidiagonal form

SYNOPSIS

  SUBROUTINE SORGBR( VECT, M, N, K, A, LDA, TAU, WORK, LWORK, INFO )

      CHARACTER	     VECT

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

      REAL	     A(	LDA, * ), TAU( * ), WORK( LWORK	)

PURPOSE
  SORGBR generates one of the matrices Q or P**T 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)	or G(i)	respectively.

  If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of
  order	M:
  if m >= k, Q = H(1) H(2) . . . H(k) and SORGBR returns the first n columns
  of Q,	where m	>= n >=	k;
  if m < k, Q =	H(1) H(2) . . .	H(m-1) and SORGBR returns Q as an M-by-M
  matrix.

  If VECT = 'P', A is assumed to have been a K-by-N matrix, and	P**T is	of
  order	N:
  if k < n, P**T = G(k)	. . . G(2) G(1)	and SORGBR returns the first m rows
  of P**T, where n >= m	>= k;
  if k >= n, P**T = G(n-1) . . . G(2) G(1) and SORGBR returns P**T as an N-
  by-N matrix.

ARGUMENTS

  VECT	  (input) CHARACTER*1
	  Specifies whether the	matrix Q or the	matrix P**T is required, as
	  defined in the transformation	applied	by SGEBRD:
	  = 'Q':  generate Q;
	  = 'P':  generate P**T.

  M	  (input) INTEGER
	  The number of	rows of	the matrix Q or	P**T to	be returned.  M	>= 0.

  N	  (input) INTEGER
	  The number of	columns	of the matrix Q	or P**T	to be returned.	 N >=
	  0.  If VECT =	'Q', M >= N >= min(M,K); if VECT = 'P',	N >= M >=
	  min(N,K).

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

  A	  (input/output) REAL array, dimension (LDA,N)
	  On entry, the	vectors	which define the elementary reflectors,	as
	  returned by SGEBRD.  On exit,	the M-by-N matrix Q or P**T.

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

  TAU	  (input) REAL array, dimension
	  (min(M,K)) if	VECT = 'Q' (min(N,K)) if VECT =	'P' TAU(i) must	con-
	  tain the scalar factor of the	elementary reflector H(i) or G(i),
	  which	determines Q or	P**T, as returned by SGEBRD in its array
	  argument TAUQ	or TAUP.

  WORK	  (workspace) 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,min(M,N)).  For
	  optimum performance LWORK >= min(M,N)*NB, where NB is	the optimal
	  blocksize.

  INFO	  (output) INTEGER
	  = 0:	successful exit
	  < 0:	if INFO	= -i, the i-th argument	had an illegal value