cqrt15()

subroutine cqrt15	(	integer	scale,
		integer	rksel,
		integer	m,
		integer	n,
		integer	nrhs,
		complex, dimension( lda, * )	a,
		integer	lda,
		complex, dimension( ldb, * )	b,
		integer	ldb,
		real, dimension( * )	s,
		integer	rank,
		real	norma,
		real	normb,
		integer, dimension( 4 )	iseed,
		complex, dimension( lwork )	work,
		integer	lwork )

CQRT15

Purpose:

!>
!> CQRT15 generates a matrix with full or deficient rank and of various
!> norms.
!> 

Parameters

[in]	SCALE	!> SCALE is INTEGER !> SCALE = 1: normally scaled matrix !> SCALE = 2: matrix scaled up !> SCALE = 3: matrix scaled down !>
[in]	RKSEL	!> RKSEL is INTEGER !> RKSEL = 1: full rank matrix !> RKSEL = 2: rank-deficient matrix !>
[in]	M	!> M is INTEGER !> The number of rows of the matrix A. !>
[in]	N	!> N is INTEGER !> The number of columns of A. !>
[in]	NRHS	!> NRHS is INTEGER !> The number of columns of B. !>
[out]	A	!> A is COMPLEX array, dimension (LDA,N) !> The M-by-N matrix A. !>
[in]	LDA	!> LDA is INTEGER !> The leading dimension of the array A. !>
[out]	B	!> B is COMPLEX array, dimension (LDB, NRHS) !> A matrix that is in the range space of matrix A. !>
[in]	LDB	!> LDB is INTEGER !> The leading dimension of the array B. !>
[out]	S	!> S is REAL array, dimension MIN(M,N) !> Singular values of A. !>
[out]	RANK	!> RANK is INTEGER !> number of nonzero singular values of A. !>
[out]	NORMA	!> NORMA is REAL !> one-norm norm of A. !>
[out]	NORMB	!> NORMB is REAL !> one-norm norm of B. !>
[in,out]	ISEED	!> ISEED is integer array, dimension (4) !> seed for random number generator. !>
[out]	WORK	!> WORK is COMPLEX array, dimension (LWORK) !>
[in]	LWORK	!> LWORK is INTEGER !> length of work space required. !> LWORK >= MAX(M+MIN(M,N),NRHS*MIN(M,N),2*N+M) !>

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 147 of file cqrt15.f.

*
*  -- LAPACK test routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      INTEGER            LDA, LDB, LWORK, M, N, NRHS, RANK, RKSEL, SCALE
      REAL               NORMA, NORMB
*     ..
*     .. Array Arguments ..
      INTEGER            ISEED( 4 )
      REAL               S( * )
      COMPLEX            A( LDA, * ), B( LDB, * ), WORK( LWORK )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               ZERO, ONE, TWO, SVMIN
      parameter( zero = 0.0e+0, one = 1.0e+0, two = 2.0e+0,
     $                   svmin = 0.1e+0 )
      COMPLEX            CZERO, CONE
      parameter( czero = ( 0.0e+0, 0.0e+0 ),
     $                   cone = ( 1.0e+0, 0.0e+0 ) )
*     ..
*     .. Local Scalars ..
      INTEGER            INFO, J, MN
      REAL               BIGNUM, EPS, SMLNUM, TEMP
*     ..
*     .. Local Arrays ..
      REAL               DUMMY( 1 )
*     ..
*     .. External Functions ..
      REAL               CLANGE, SASUM, SCNRM2, SLAMCH, SLARND
      EXTERNAL           clange, sasum, scnrm2, slamch, slarnd
*     ..
*     .. External Subroutines ..
      EXTERNAL           cgemm, clarf, clarnv, claror, clascl, claset,
     $                   csscal, slaord, slascl, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, cmplx, max, min
*     ..
*     .. Executable Statements ..
*
      mn = min( m, n )
      IF( lwork.LT.max( m+mn, mn*nrhs, 2*n+m ) ) THEN
         CALL xerbla( 'CQRT15', 16 )
         RETURN
      END IF
*
      smlnum = slamch( 'Safe minimum' )
      bignum = one / smlnum
      eps = slamch( '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( 'CQRT15', 2 )
      END IF
*
      IF( rank.GT.0 ) THEN
*
*        Nontrivial case
*
         s( 1 ) = one
         DO 30 j = 2, rank
   20       CONTINUE
            temp = slarnd( 1, iseed )
            IF( temp.GT.svmin ) THEN
               s( j ) = abs( temp )
            ELSE
               GO TO 20
            END IF
   30    CONTINUE
         CALL slaord( 'Decreasing', rank, s, 1 )
*
*        Generate 'rank' columns of a random orthogonal matrix in A
*
         CALL clarnv( 2, iseed, m, work )
         CALL csscal( m, one / scnrm2( m, work, 1 ), work, 1 )
         CALL claset( 'Full', m, rank, czero, cone, a, lda )
         CALL clarf( 'Left', m, rank, work, 1, cmplx( two ), a, lda,
     $               work( m+1 ) )
*
*        workspace used: m+mn
*
*        Generate consistent rhs in the range space of A
*
         CALL clarnv( 2, iseed, rank*nrhs, work )
         CALL cgemm( '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 csscal( m, s( j ), a( 1, j ), 1 )
   40    CONTINUE
         IF( rank.LT.n )
     $      CALL claset( 'Full', m, n-rank, czero, czero,
     $                   a( 1, rank+1 ), lda )
         CALL claror( '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 claset( 'Full', m, n, czero, czero, a, lda )
         CALL claset( 'Full', m, nrhs, czero, czero, b, ldb )
*
      END IF
*
*     Scale the matrix
*
      IF( scale.NE.1 ) THEN
         norma = clange( 'Max', m, n, a, lda, dummy )
         IF( norma.NE.zero ) THEN
            IF( scale.EQ.2 ) THEN
*
*              matrix scaled up
*
               CALL clascl( 'General', 0, 0, norma, bignum, m, n, a,
     $                      lda, info )
               CALL slascl( 'General', 0, 0, norma, bignum, mn, 1, s,
     $                      mn, info )
               CALL clascl( 'General', 0, 0, norma, bignum, m, nrhs, b,
     $                      ldb, info )
            ELSE IF( scale.EQ.3 ) THEN
*
*              matrix scaled down
*
               CALL clascl( 'General', 0, 0, norma, smlnum, m, n, a,
     $                      lda, info )
               CALL slascl( 'General', 0, 0, norma, smlnum, mn, 1, s,
     $                      mn, info )
               CALL clascl( 'General', 0, 0, norma, smlnum, m, nrhs, b,
     $                      ldb, info )
            ELSE
               CALL xerbla( 'CQRT15', 1 )
               RETURN
            END IF
         END IF
      END IF
*
      norma = sasum( mn, s, 1 )
      normb = clange( 'One-norm', m, nrhs, b, ldb, dummy )
*
      RETURN
*
*     End of CQRT15
*

Here is the call graph for this function:

Here is the caller graph for this function: