sormtr()

subroutine sormtr	(	character	side,
		character	uplo,
		character	trans,
		integer	m,
		integer	n,
		real, dimension( lda, * )	a,
		integer	lda,
		real, dimension( * )	tau,
		real, dimension( ldc, * )	c,
		integer	ldc,
		real, dimension( * )	work,
		integer	lwork,
		integer	info
	)

SORMTR

Download SORMTR + dependencies [TGZ] [ZIP] [TXT]

Purpose:

 SORMTR 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

 where Q is a real orthogonal matrix of order nq, with nq = m if
 SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of
 nq-1 elementary reflectors, as returned by SSYTRD:

 if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);

 if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

Parameters

[in]	SIDE	SIDE is CHARACTER*1 = 'L': apply Q or Q**T from the Left; = 'R': apply Q or Q**T from the Right.
[in]	UPLO	UPLO is CHARACTER*1 = 'U': Upper triangle of A contains elementary reflectors from SSYTRD; = 'L': Lower triangle of A contains elementary reflectors from SSYTRD.
[in]	TRANS	TRANS is CHARACTER*1 = 'N': No transpose, apply Q; = 'T': Transpose, apply Q**T.
[in]	M	M is INTEGER The number of rows of the matrix C. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix C. N >= 0.
[in]	A	A is REAL array, dimension (LDA,M) if SIDE = 'L' (LDA,N) if SIDE = 'R' The vectors which define the elementary reflectors, as returned by SSYTRD.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'.
[in]	TAU	TAU is REAL array, dimension (M-1) if SIDE = 'L' (N-1) if SIDE = 'R' TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SSYTRD.
[in,out]	C	C is 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.
[in]	LDC	LDC is INTEGER The leading dimension of the array C. LDC >= max(1,M).
[out]	WORK	WORK is REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
[in]	LWORK	LWORK is 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 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.
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 170 of file sormtr.f.

*
*  -- LAPACK computational routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      CHARACTER          SIDE, TRANS, UPLO
      INTEGER            INFO, LDA, LDC, LWORK, M, N
*     ..
*     .. Array Arguments ..
      REAL               A( LDA, * ), C( LDC, * ), TAU( * ),
     $                   WORK( * )
*     ..
*
*  =====================================================================
*
*     .. Local Scalars ..
      LOGICAL            LEFT, LQUERY, UPPER
      INTEGER            I1, I2, IINFO, LWKOPT, MI, NI, NB, NQ, NW
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      INTEGER            ILAENV
      REAL               SROUNDUP_LWORK
      EXTERNAL           ilaenv, lsame, sroundup_lwork
*     ..
*     .. External Subroutines ..
      EXTERNAL           sormql, sormqr, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max
*     ..
*     .. Executable Statements ..
*
*     Test the input arguments
*
      info = 0
      left = lsame( side, 'L' )
      upper = lsame( uplo, 'U' )
      lquery = ( lwork.EQ.-1 )
*
*     NQ is the order of Q and NW is the minimum dimension of WORK
*
      IF( left ) THEN
         nq = m
         nw = max( 1, n )
      ELSE
         nq = n
         nw = max( 1, m )
      END IF
      IF( .NOT.left .AND. .NOT.lsame( side, 'R' ) ) THEN
         info = -1
      ELSE IF( .NOT.upper .AND. .NOT.lsame( uplo, 'L' ) ) THEN
         info = -2
      ELSE IF( .NOT.lsame( trans, 'N' ) .AND. .NOT.lsame( trans, 'T' ) )
     $          THEN
         info = -3
      ELSE IF( m.LT.0 ) THEN
         info = -4
      ELSE IF( n.LT.0 ) THEN
         info = -5
      ELSE IF( lda.LT.max( 1, nq ) ) THEN
         info = -7
      ELSE IF( ldc.LT.max( 1, m ) ) THEN
         info = -10
      ELSE IF( lwork.LT.nw .AND. .NOT.lquery ) THEN
         info = -12
      END IF
*
      IF( info.EQ.0 ) THEN
         IF( upper ) THEN
            IF( left ) THEN
               nb = ilaenv( 1, 'SORMQL', side // trans, m-1, n, m-1,
     $                      -1 )
            ELSE
               nb = ilaenv( 1, 'SORMQL', side // trans, m, n-1, n-1,
     $                      -1 )
            END IF
         ELSE
            IF( left ) THEN
               nb = ilaenv( 1, 'SORMQR', side // trans, m-1, n, m-1,
     $                      -1 )
            ELSE
               nb = ilaenv( 1, 'SORMQR', side // trans, m, n-1, n-1,
     $                      -1 )
            END IF
         END IF
         lwkopt = nw*nb
         work( 1 ) = sroundup_lwork(lwkopt)
      END IF
*
      IF( info.NE.0 ) THEN
         CALL xerbla( 'SORMTR', -info )
         RETURN
      ELSE IF( lquery ) THEN
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( m.EQ.0 .OR. n.EQ.0 .OR. nq.EQ.1 ) THEN
         work( 1 ) = 1
         RETURN
      END IF
*
      IF( left ) THEN
         mi = m - 1
         ni = n
      ELSE
         mi = m
         ni = n - 1
      END IF
*
      IF( upper ) THEN
*
*        Q was determined by a call to SSYTRD with UPLO = 'U'
*
         CALL sormql( side, trans, mi, ni, nq-1, a( 1, 2 ), lda, tau, c,
     $                ldc, work, lwork, iinfo )
      ELSE
*
*        Q was determined by a call to SSYTRD with UPLO = 'L'
*
         IF( left ) THEN
            i1 = 2
            i2 = 1
         ELSE
            i1 = 1
            i2 = 2
         END IF
         CALL sormqr( side, trans, mi, ni, nq-1, a( 2, 1 ), lda, tau,
     $                c( i1, i2 ), ldc, work, lwork, iinfo )
      END IF
      work( 1 ) = sroundup_lwork(lwkopt)
      RETURN
*
*     End of SORMTR
*

Here is the call graph for this function:

Here is the caller graph for this function: