zlaror.f

Go to the documentation of this file.

      SUBROUTINE zlaror( SIDE, INIT, M, N, A, LDA, ISEED, X, INFO )
*
*  -- LAPACK auxiliary test routine (version 3.1) --
*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
*     November 2006
*
*     .. Scalar Arguments ..
      CHARACTER          init, side
      INTEGER            info, lda, m, n
*     ..
*     .. Array Arguments ..
      INTEGER            iseed( 4 )
      COMPLEX*16         a( lda, * ), x( * )
*     ..
*
*  Purpose
*  =======
*
*     ZLAROR pre- or post-multiplies an M by N matrix A by a random
*     unitary matrix U, overwriting A. A may optionally be
*     initialized to the identity matrix before multiplying by U.
*     U is generated using the method of G.W. Stewart
*     ( SIAM J. Numer. Anal. 17, 1980, pp. 403-409 ).
*     (BLAS-2 version)
*
*  Arguments
*  =========
*
*  SIDE   - CHARACTER*1
*           SIDE specifies whether A is multiplied on the left or right
*           by U.
*       SIDE = 'L'   Multiply A on the left (premultiply) by U
*       SIDE = 'R'   Multiply A on the right (postmultiply) by U*
*       SIDE = 'C'   Multiply A on the left by U and the right by U*
*       SIDE = 'T'   Multiply A on the left by U and the right by U'
*           Not modified.
*
*  INIT   - CHARACTER*1
*           INIT specifies whether or not A should be initialized to
*           the identity matrix.
*              INIT = 'I'   Initialize A to (a section of) the
*                           identity matrix before applying U.
*              INIT = 'N'   No initialization.  Apply U to the
*                           input matrix A.
*
*           INIT = 'I' may be used to generate square (i.e., unitary)
*           or rectangular orthogonal matrices (orthogonality being
*           in the sense of ZDOTC):
*
*           For square matrices, M=N, and SIDE many be either 'L' or
*           'R'; the rows will be orthogonal to each other, as will the
*           columns.
*           For rectangular matrices where M < N, SIDE = 'R' will
*           produce a dense matrix whose rows will be orthogonal and
*           whose columns will not, while SIDE = 'L' will produce a
*           matrix whose rows will be orthogonal, and whose first M
*           columns will be orthogonal, the remaining columns being
*           zero.
*           For matrices where M > N, just use the previous
*           explaination, interchanging 'L' and 'R' and "rows" and
*           "columns".
*
*           Not modified.
*
*  M      - INTEGER
*           Number of rows of A. Not modified.
*
*  N      - INTEGER
*           Number of columns of A. Not modified.
*
*  A      - COMPLEX*16 array, dimension ( LDA, N )
*           Input and output array. Overwritten by U A ( if SIDE = 'L' )
*           or by A U ( if SIDE = 'R' )
*           or by U A U* ( if SIDE = 'C')
*           or by U A U' ( if SIDE = 'T') on exit.
*
*  LDA    - INTEGER
*           Leading dimension of A. Must be at least MAX ( 1, M ).
*           Not modified.
*
*  ISEED  - INTEGER array, dimension ( 4 )
*           On entry ISEED specifies the seed of the random number
*           generator. The array elements should be between 0 and 4095;
*           if not they will be reduced mod 4096.  Also, ISEED(4) must
*           be odd.  The random number generator uses a linear
*           congruential sequence limited to small integers, and so
*           should produce machine independent random numbers. The
*           values of ISEED are changed on exit, and can be used in the
*           next call to ZLAROR to continue the same random number
*           sequence.
*           Modified.
*
*  X      - COMPLEX*16 array, dimension ( 3*MAX( M, N ) )
*           Workspace. Of length:
*               2*M + N if SIDE = 'L',
*               2*N + M if SIDE = 'R',
*               3*N     if SIDE = 'C' or 'T'.
*           Modified.
*
*  INFO   - INTEGER
*           An error flag.  It is set to:
*            0  if no error.
*            1  if ZLARND returned a bad random number (installation
*               problem)
*           -1  if SIDE is not L, R, C, or T.
*           -3  if M is negative.
*           -4  if N is negative or if SIDE is C or T and N is not equal
*               to M.
*           -6  if LDA is less than M.
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   zero, one, toosml
      parameter( zero = 0.0d+0, one = 1.0d+0,
     $                   toosml = 1.0d-20 )
      COMPLEX*16         czero, cone
      parameter( czero = ( 0.0d+0, 0.0d+0 ),
     $                   cone = ( 1.0d+0, 0.0d+0 ) )
*     ..
*     .. Local Scalars ..
      INTEGER            irow, itype, ixfrm, j, jcol, kbeg, nxfrm
      DOUBLE PRECISION   factor, xabs, xnorm
      COMPLEX*16         csign, xnorms
*     ..
*     .. External Functions ..
      LOGICAL            lsame
      DOUBLE PRECISION   dznrm2
      COMPLEX*16         zlarnd
      EXTERNAL           lsame, dznrm2, zlarnd
*     ..
*     .. External Subroutines ..
      EXTERNAL           xerbla, zgemv, zgerc, zlacgv, zlaset, zscal
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, dcmplx, dconjg
*     ..
*     .. Executable Statements ..
*
      IF( n.EQ.0 .OR. m.EQ.0 )
     $   return
*
      itype = 0
      IF( lsame( side, 'L' ) ) THEN
         itype = 1
      ELSE IF( lsame( side, 'R' ) ) THEN
         itype = 2
      ELSE IF( lsame( side, 'C' ) ) THEN
         itype = 3
      ELSE IF( lsame( side, 'T' ) ) THEN
         itype = 4
      END IF
*
*     Check for argument errors.
*
      info = 0
      IF( itype.EQ.0 ) THEN
         info = -1
      ELSE IF( m.LT.0 ) THEN
         info = -3
      ELSE IF( n.LT.0 .OR. ( itype.EQ.3 .AND. n.NE.m ) ) THEN
         info = -4
      ELSE IF( lda.LT.m ) THEN
         info = -6
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'ZLAROR', -info )
         return
      END IF
*
      IF( itype.EQ.1 ) THEN
         nxfrm = m
      ELSE
         nxfrm = n
      END IF
*
*     Initialize A to the identity matrix if desired
*
      IF( lsame( init, 'I' ) )
     $   CALL zlaset( 'Full', m, n, czero, cone, a, lda )
*
*     If no rotation possible, still multiply by
*     a random complex number from the circle |x| = 1
*
*      2)      Compute Rotation by computing Householder
*              Transformations H(2), H(3), ..., H(n).  Note that the
*              order in which they are computed is irrelevant.
*
      DO 10 j = 1, nxfrm
         x( j ) = czero
   10 continue
*
      DO 30 ixfrm = 2, nxfrm
         kbeg = nxfrm - ixfrm + 1
*
*        Generate independent normal( 0, 1 ) random numbers
*
         DO 20 j = kbeg, nxfrm
            x( j ) = zlarnd( 3, iseed )
   20    continue
*
*        Generate a Householder transformation from the random vector X
*
         xnorm = dznrm2( ixfrm, x( kbeg ), 1 )
         xabs = abs( x( kbeg ) )
         IF( xabs.NE.czero ) THEN
            csign = x( kbeg ) / xabs
         ELSE
            csign = cone
         END IF
         xnorms = csign*xnorm
         x( nxfrm+kbeg ) = -csign
         factor = xnorm*( xnorm+xabs )
         IF( abs( factor ).LT.toosml ) THEN
            info = 1
            CALL xerbla( 'ZLAROR', -info )
            return
         ELSE
            factor = one / factor
         END IF
         x( kbeg ) = x( kbeg ) + xnorms
*
*        Apply Householder transformation to A
*
         IF( itype.EQ.1 .OR. itype.EQ.3 .OR. itype.EQ.4 ) THEN
*
*           Apply H(k) on the left of A
*
            CALL zgemv( 'C', ixfrm, n, cone, a( kbeg, 1 ), lda,
     $                  x( kbeg ), 1, czero, x( 2*nxfrm+1 ), 1 )
            CALL zgerc( ixfrm, n, -dcmplx( factor ), x( kbeg ), 1,
     $                  x( 2*nxfrm+1 ), 1, a( kbeg, 1 ), lda )
*
         END IF
*
         IF( itype.GE.2 .AND. itype.LE.4 ) THEN
*
*           Apply H(k)* (or H(k)') on the right of A
*
            IF( itype.EQ.4 ) THEN
               CALL zlacgv( ixfrm, x( kbeg ), 1 )
            END IF
*
            CALL zgemv( 'N', m, ixfrm, cone, a( 1, kbeg ), lda,
     $                  x( kbeg ), 1, czero, x( 2*nxfrm+1 ), 1 )
            CALL zgerc( m, ixfrm, -dcmplx( factor ), x( 2*nxfrm+1 ), 1,
     $                  x( kbeg ), 1, a( 1, kbeg ), lda )
*
         END IF
   30 continue
*
      x( 1 ) = zlarnd( 3, iseed )
      xabs = abs( x( 1 ) )
      IF( xabs.NE.zero ) THEN
         csign = x( 1 ) / xabs
      ELSE
         csign = cone
      END IF
      x( 2*nxfrm ) = csign
*
*     Scale the matrix A by D.
*
      IF( itype.EQ.1 .OR. itype.EQ.3 .OR. itype.EQ.4 ) THEN
         DO 40 irow = 1, m
            CALL zscal( n, dconjg( x( nxfrm+irow ) ), a( irow, 1 ),
     $                  lda )
   40    continue
      END IF
*
      IF( itype.EQ.2 .OR. itype.EQ.3 ) THEN
         DO 50 jcol = 1, n
            CALL zscal( m, x( nxfrm+jcol ), a( 1, jcol ), 1 )
   50    continue
      END IF
*
      IF( itype.EQ.4 ) THEN
         DO 60 jcol = 1, n
            CALL zscal( m, dconjg( x( nxfrm+jcol ) ), a( 1, jcol ), 1 )
   60    continue
      END IF
      return
*
*     End of ZLAROR
*
      END