zqrt15.f

Go to the documentation of this file.

*> \brief \b ZQRT15
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at 
*            http://www.netlib.org/lapack/explore-html/ 
*
*  Definition:
*  ===========
*
*       SUBROUTINE ZQRT15( SCALE, RKSEL, M, N, NRHS, A, LDA, B, LDB, S,
*                          RANK, NORMA, NORMB, ISEED, WORK, LWORK )
* 
*       .. Scalar Arguments ..
*       INTEGER            LDA, LDB, LWORK, M, N, NRHS, RANK, RKSEL, SCALE
*       DOUBLE PRECISION   NORMA, NORMB
*       ..
*       .. Array Arguments ..
*       INTEGER            ISEED( 4 )
*       DOUBLE PRECISION   S( * )
*       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( LWORK )
*       ..
*  
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> ZQRT15 generates a matrix with full or deficient rank and of various
*> norms.
*> \endverbatim
*
*  Arguments:
*  ==========
*
*> \param[in] SCALE
*> \verbatim
*>          SCALE is INTEGER
*>          SCALE = 1: normally scaled matrix
*>          SCALE = 2: matrix scaled up
*>          SCALE = 3: matrix scaled down
*> \endverbatim
*>
*> \param[in] RKSEL
*> \verbatim
*>          RKSEL is INTEGER
*>          RKSEL = 1: full rank matrix
*>          RKSEL = 2: rank-deficient matrix
*> \endverbatim
*>
*> \param[in] M
*> \verbatim
*>          M is INTEGER
*>          The number of rows of the matrix A.
*> \endverbatim
*>
*> \param[in] N
*> \verbatim
*>          N is INTEGER
*>          The number of columns of A.
*> \endverbatim
*>
*> \param[in] NRHS
*> \verbatim
*>          NRHS is INTEGER
*>          The number of columns of B.
*> \endverbatim
*>
*> \param[out] A
*> \verbatim
*>          A is COMPLEX*16 array, dimension (LDA,N)
*>          The M-by-N matrix A.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*>          LDA is INTEGER
*>          The leading dimension of the array A.
*> \endverbatim
*>
*> \param[out] B
*> \verbatim
*>          B is COMPLEX*16 array, dimension (LDB, NRHS)
*>          A matrix that is in the range space of matrix A.
*> \endverbatim
*>
*> \param[in] LDB
*> \verbatim
*>          LDB is INTEGER
*>          The leading dimension of the array B.
*> \endverbatim
*>
*> \param[out] S
*> \verbatim
*>          S is DOUBLE PRECISION array, dimension MIN(M,N)
*>          Singular values of A.
*> \endverbatim
*>
*> \param[out] RANK
*> \verbatim
*>          RANK is INTEGER
*>          number of nonzero singular values of A.
*> \endverbatim
*>
*> \param[out] NORMA
*> \verbatim
*>          NORMA is DOUBLE PRECISION
*>          one-norm norm of A.
*> \endverbatim
*>
*> \param[out] NORMB
*> \verbatim
*>          NORMB is DOUBLE PRECISION
*>          one-norm norm of B.
*> \endverbatim
*>
*> \param[in,out] ISEED
*> \verbatim
*>          ISEED is integer array, dimension (4)
*>          seed for random number generator.
*> \endverbatim
*>
*> \param[out] WORK
*> \verbatim
*>          WORK is COMPLEX*16 array, dimension (LWORK)
*> \endverbatim
*>
*> \param[in] LWORK
*> \verbatim
*>          LWORK is INTEGER
*>          length of work space required.
*>          LWORK >= MAX(M+MIN(M,N),NRHS*MIN(M,N),2*N+M)
*> \endverbatim
*
*  Authors:
*  ========
*
*> \author Univ. of Tennessee 
*> \author Univ. of California Berkeley 
*> \author Univ. of Colorado Denver 
*> \author NAG Ltd. 
*
*> \date November 2011
*
*> \ingroup complex16_lin
*
*  =====================================================================
      SUBROUTINE zqrt15( SCALE, RKSEL, M, N, NRHS, A, LDA, B, LDB, S,
     $                   rank, norma, normb, iseed, work, lwork )
*
*  -- LAPACK test routine (version 3.4.0) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     November 2011
*
*     .. Scalar Arguments ..
      INTEGER            lda, ldb, lwork, m, n, nrhs, rank, rksel, scale
      DOUBLE PRECISION   norma, normb
*     ..
*     .. Array Arguments ..
      INTEGER            iseed( 4 )
      DOUBLE PRECISION   s( * )
      COMPLEX*16         a( lda, * ), b( ldb, * ), work( lwork )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   zero, one, two, svmin
      parameter( zero = 0.0d+0, one = 1.0d+0, two = 2.0d+0,
     $                   svmin = 0.1d+0 )
      COMPLEX*16         czero, cone
      parameter( czero = ( 0.0d+0, 0.0d+0 ),
     $                   cone = ( 1.0d+0, 0.0d+0 ) )
*     ..
*     .. Local Scalars ..
      INTEGER            info, j, mn
      DOUBLE PRECISION   bignum, eps, smlnum, temp
*     ..
*     .. Local Arrays ..
      DOUBLE PRECISION   dummy( 1 )
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   dasum, dlamch, dlarnd, dznrm2, zlange
      EXTERNAL           dasum, dlamch, dlarnd, dznrm2, zlange
*     ..
*     .. External Subroutines ..
      EXTERNAL           dlabad, dlaord, dlascl, xerbla, zdscal, zgemm,
     $                   zlarf, zlarnv, zlaror, zlascl, zlaset
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, dcmplx, max, min
*     ..
*     .. Executable Statements ..
*
      mn = min( m, n )
      IF( lwork.LT.max( m+mn, mn*nrhs, 2*n+m ) ) THEN
         CALL xerbla( 'ZQRT15', 16 )
         return
      END IF
*
      smlnum = dlamch( 'Safe minimum' )
      bignum = one / smlnum
      CALL dlabad( smlnum, bignum )
      eps = dlamch( 'Epsilon' )
      smlnum = ( smlnum / eps ) / eps
      bignum = one / smlnum
*
*     Determine rank and (unscaled) singular values
*
      IF( rksel.EQ.1 ) THEN
         rank = mn
      ELSE IF( rksel.EQ.2 ) THEN
         rank = ( 3*mn ) / 4
         DO 10 j = rank + 1, mn
            s( j ) = zero
   10    continue
      ELSE
         CALL xerbla( 'ZQRT15', 2 )
      END IF
*
      IF( rank.GT.0 ) THEN
*
*        Nontrivial case
*
         s( 1 ) = one
         DO 30 j = 2, rank
   20       continue
            temp = dlarnd( 1, iseed )
            IF( temp.GT.svmin ) THEN
               s( j ) = abs( temp )
            ELSE
               go to 20
            END IF
   30    continue
         CALL dlaord( 'Decreasing', rank, s, 1 )
*
*        Generate 'rank' columns of a random orthogonal matrix in A
*
         CALL zlarnv( 2, iseed, m, work )
         CALL zdscal( m, one / dznrm2( m, work, 1 ), work, 1 )
         CALL zlaset( 'Full', m, rank, czero, cone, a, lda )
         CALL zlarf( 'Left', m, rank, work, 1, dcmplx( two ), a, lda,
     $               work( m+1 ) )
*
*        workspace used: m+mn
*
*        Generate consistent rhs in the range space of A
*
         CALL zlarnv( 2, iseed, rank*nrhs, work )
         CALL zgemm( 'No transpose', 'No transpose', m, nrhs, rank,
     $               cone, a, lda, work, rank, czero, b, ldb )
*
*        work space used: <= mn *nrhs
*
*        generate (unscaled) matrix A
*
         DO 40 j = 1, rank
            CALL zdscal( m, s( j ), a( 1, j ), 1 )
   40    continue
         IF( rank.LT.n )
     $      CALL zlaset( 'Full', m, n-rank, czero, czero,
     $                   a( 1, rank+1 ), lda )
         CALL zlaror( 'Right', 'No initialization', m, n, a, lda, iseed,
     $                work, info )
*
      ELSE
*
*        work space used 2*n+m
*
*        Generate null matrix and rhs
*
         DO 50 j = 1, mn
            s( j ) = zero
   50    continue
         CALL zlaset( 'Full', m, n, czero, czero, a, lda )
         CALL zlaset( 'Full', m, nrhs, czero, czero, b, ldb )
*
      END IF
*
*     Scale the matrix
*
      IF( scale.NE.1 ) THEN
         norma = zlange( 'Max', m, n, a, lda, dummy )
         IF( norma.NE.zero ) THEN
            IF( scale.EQ.2 ) THEN
*
*              matrix scaled up
*
               CALL zlascl( 'General', 0, 0, norma, bignum, m, n, a,
     $                      lda, info )
               CALL dlascl( 'General', 0, 0, norma, bignum, mn, 1, s,
     $                      mn, info )
               CALL zlascl( 'General', 0, 0, norma, bignum, m, nrhs, b,
     $                      ldb, info )
            ELSE IF( scale.EQ.3 ) THEN
*
*              matrix scaled down
*
               CALL zlascl( 'General', 0, 0, norma, smlnum, m, n, a,
     $                      lda, info )
               CALL dlascl( 'General', 0, 0, norma, smlnum, mn, 1, s,
     $                      mn, info )
               CALL zlascl( 'General', 0, 0, norma, smlnum, m, nrhs, b,
     $                      ldb, info )
            ELSE
               CALL xerbla( 'ZQRT15', 1 )
               return
            END IF
         END IF
      END IF
*
      norma = dasum( mn, s, 1 )
      normb = zlange( 'One-norm', m, nrhs, b, ldb, dummy )
*
      return
*
*     End of ZQRT15
*
      END