sormhr()

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

SORMHR

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

Purpose:

!>
!> SORMHR 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
!> IHI-ILO elementary reflectors, as returned by SGEHRD:
!>
!> Q = H(ilo) H(ilo+1) . . . H(ihi-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]	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]	ILO	!> ILO is INTEGER !>
[in]	IHI	!> IHI is INTEGER !> !> ILO and IHI must have the same values as in the previous call !> of SGEHRD. Q is equal to the unit matrix except in the !> submatrix Q(ilo+1:ihi,ilo+1:ihi). !> If SIDE = 'L', then 1 <= ILO <= IHI <= M, if M > 0, and !> ILO = 1 and IHI = 0, if M = 0; !> if SIDE = 'R', then 1 <= ILO <= IHI <= N, if N > 0, and !> ILO = 1 and IHI = 0, if 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 SGEHRD. !>
[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 SGEHRD. !>
[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 175 of file sormhr.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
      INTEGER            IHI, ILO, INFO, LDA, LDC, LWORK, M, N
*     ..
*     .. Array Arguments ..
      REAL               A( LDA, * ), C( LDC, * ), TAU( * ),
     $                   WORK( * )
*     ..
*
*  =====================================================================
*
*     .. Local Scalars ..
      LOGICAL            LEFT, LQUERY
      INTEGER            I1, I2, IINFO, LWKOPT, MI, NB, NH, NI, NQ, NW
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      INTEGER            ILAENV
      REAL               SROUNDUP_LWORK
      EXTERNAL           ilaenv, lsame, sroundup_lwork
*     ..
*     .. External Subroutines ..
      EXTERNAL           sormqr, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max, min
*     ..
*     .. Executable Statements ..
*
*     Test the input arguments
*
      info = 0
      nh = ihi - ilo
      left = lsame( side, 'L' )
      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.lsame( trans, 'N' ) .AND.
     $         .NOT.lsame( trans, 'T' ) )
     $          THEN
         info = -2
      ELSE IF( m.LT.0 ) THEN
         info = -3
      ELSE IF( n.LT.0 ) THEN
         info = -4
      ELSE IF( ilo.LT.1 .OR. ilo.GT.max( 1, nq ) ) THEN
         info = -5
      ELSE IF( ihi.LT.min( ilo, nq ) .OR. ihi.GT.nq ) THEN
         info = -6
      ELSE IF( lda.LT.max( 1, nq ) ) THEN
         info = -8
      ELSE IF( ldc.LT.max( 1, m ) ) THEN
         info = -11
      ELSE IF( lwork.LT.nw .AND. .NOT.lquery ) THEN
         info = -13
      END IF
*
      IF( info.EQ.0 ) THEN
         IF( left ) THEN
            nb = ilaenv( 1, 'SORMQR', side // trans, nh, n, nh, -1 )
         ELSE
            nb = ilaenv( 1, 'SORMQR', side // trans, m, nh, nh, -1 )
         END IF
         lwkopt = nw*nb
         work( 1 ) = sroundup_lwork(lwkopt)
      END IF
*
      IF( info.NE.0 ) THEN
         CALL xerbla( 'SORMHR', -info )
         RETURN
      ELSE IF( lquery ) THEN
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( m.EQ.0 .OR. n.EQ.0 .OR. nh.EQ.0 ) THEN
         work( 1 ) = 1
         RETURN
      END IF
*
      IF( left ) THEN
         mi = nh
         ni = n
         i1 = ilo + 1
         i2 = 1
      ELSE
         mi = m
         ni = nh
         i1 = 1
         i2 = ilo + 1
      END IF
*
      CALL sormqr( side, trans, mi, ni, nh, a( ilo+1, ilo ), lda,
     $             tau( ilo ), c( i1, i2 ), ldc, work, lwork, iinfo )
*
      work( 1 ) = sroundup_lwork(lwkopt)
      RETURN
*
*     End of SORMHR
*

Here is the call graph for this function:

Here is the caller graph for this function: