ddrvls.f

Go to the documentation of this file.

*> \brief \b DDRVLS
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at 
*            http://www.netlib.org/lapack/explore-html/ 
*
*  Definition:
*  ===========
*
*       SUBROUTINE DDRVLS( DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB,
*                          NBVAL, NXVAL, THRESH, TSTERR, A, COPYA, B,
*                          COPYB, C, S, COPYS, WORK, IWORK, NOUT )
* 
*       .. Scalar Arguments ..
*       LOGICAL            TSTERR
*       INTEGER            NM, NN, NNB, NNS, NOUT
*       DOUBLE PRECISION   THRESH
*       ..
*       .. Array Arguments ..
*       LOGICAL            DOTYPE( * )
*       INTEGER            IWORK( * ), MVAL( * ), NBVAL( * ), NSVAL( * ),
*      $                   NVAL( * ), NXVAL( * )
*       DOUBLE PRECISION   A( * ), B( * ), C( * ), COPYA( * ), COPYB( * ),
*      $                   COPYS( * ), S( * ), WORK( * )
*       ..
*  
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> DDRVLS tests the least squares driver routines DGELS, DGELSS, DGELSY,
*> and DGELSD.
*> \endverbatim
*
*  Arguments:
*  ==========
*
*> \param[in] DOTYPE
*> \verbatim
*>          DOTYPE is LOGICAL array, dimension (NTYPES)
*>          The matrix types to be used for testing.  Matrices of type j
*>          (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
*>          .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
*>          The matrix of type j is generated as follows:
*>          j=1: A = U*D*V where U and V are random orthogonal matrices
*>               and D has random entries (> 0.1) taken from a uniform 
*>               distribution (0,1). A is full rank.
*>          j=2: The same of 1, but A is scaled up.
*>          j=3: The same of 1, but A is scaled down.
*>          j=4: A = U*D*V where U and V are random orthogonal matrices
*>               and D has 3*min(M,N)/4 random entries (> 0.1) taken
*>               from a uniform distribution (0,1) and the remaining
*>               entries set to 0. A is rank-deficient. 
*>          j=5: The same of 4, but A is scaled up.
*>          j=6: The same of 5, but A is scaled down.
*> \endverbatim
*>
*> \param[in] NM
*> \verbatim
*>          NM is INTEGER
*>          The number of values of M contained in the vector MVAL.
*> \endverbatim
*>
*> \param[in] MVAL
*> \verbatim
*>          MVAL is INTEGER array, dimension (NM)
*>          The values of the matrix row dimension M.
*> \endverbatim
*>
*> \param[in] NN
*> \verbatim
*>          NN is INTEGER
*>          The number of values of N contained in the vector NVAL.
*> \endverbatim
*>
*> \param[in] NVAL
*> \verbatim
*>          NVAL is INTEGER array, dimension (NN)
*>          The values of the matrix column dimension N.
*> \endverbatim
*>
*> \param[in] NNS
*> \verbatim
*>          NNS is INTEGER
*>          The number of values of NRHS contained in the vector NSVAL.
*> \endverbatim
*>
*> \param[in] NSVAL
*> \verbatim
*>          NSVAL is INTEGER array, dimension (NNS)
*>          The values of the number of right hand sides NRHS.
*> \endverbatim
*>
*> \param[in] NNB
*> \verbatim
*>          NNB is INTEGER
*>          The number of values of NB and NX contained in the
*>          vectors NBVAL and NXVAL.  The blocking parameters are used
*>          in pairs (NB,NX).
*> \endverbatim
*>
*> \param[in] NBVAL
*> \verbatim
*>          NBVAL is INTEGER array, dimension (NNB)
*>          The values of the blocksize NB.
*> \endverbatim
*>
*> \param[in] NXVAL
*> \verbatim
*>          NXVAL is INTEGER array, dimension (NNB)
*>          The values of the crossover point NX.
*> \endverbatim
*>
*> \param[in] THRESH
*> \verbatim
*>          THRESH is DOUBLE PRECISION
*>          The threshold value for the test ratios.  A result is
*>          included in the output file if RESULT >= THRESH.  To have
*>          every test ratio printed, use THRESH = 0.
*> \endverbatim
*>
*> \param[in] TSTERR
*> \verbatim
*>          TSTERR is LOGICAL
*>          Flag that indicates whether error exits are to be tested.
*> \endverbatim
*>
*> \param[out] A
*> \verbatim
*>          A is DOUBLE PRECISION array, dimension (MMAX*NMAX)
*>          where MMAX is the maximum value of M in MVAL and NMAX is the
*>          maximum value of N in NVAL.
*> \endverbatim
*>
*> \param[out] COPYA
*> \verbatim
*>          COPYA is DOUBLE PRECISION array, dimension (MMAX*NMAX)
*> \endverbatim
*>
*> \param[out] B
*> \verbatim
*>          B is DOUBLE PRECISION array, dimension (MMAX*NSMAX)
*>          where MMAX is the maximum value of M in MVAL and NSMAX is the
*>          maximum value of NRHS in NSVAL.
*> \endverbatim
*>
*> \param[out] COPYB
*> \verbatim
*>          COPYB is DOUBLE PRECISION array, dimension (MMAX*NSMAX)
*> \endverbatim
*>
*> \param[out] C
*> \verbatim
*>          C is DOUBLE PRECISION array, dimension (MMAX*NSMAX)
*> \endverbatim
*>
*> \param[out] S
*> \verbatim
*>          S is DOUBLE PRECISION array, dimension
*>                      (min(MMAX,NMAX))
*> \endverbatim
*>
*> \param[out] COPYS
*> \verbatim
*>          COPYS is DOUBLE PRECISION array, dimension
*>                      (min(MMAX,NMAX))
*> \endverbatim
*>
*> \param[out] WORK
*> \verbatim
*>          WORK is DOUBLE PRECISION array,
*>                      dimension (MMAX*NMAX + 4*NMAX + MMAX).
*> \endverbatim
*>
*> \param[out] IWORK
*> \verbatim
*>          IWORK is INTEGER array, dimension (15*NMAX)
*> \endverbatim
*>
*> \param[in] NOUT
*> \verbatim
*>          NOUT is INTEGER
*>          The unit number for output.
*> \endverbatim
*
*  Authors:
*  ========
*
*> \author Univ. of Tennessee 
*> \author Univ. of California Berkeley 
*> \author Univ. of Colorado Denver 
*> \author NAG Ltd. 
*
*> \date November 2015
*
*> \ingroup double_lin
*
*  =====================================================================
      SUBROUTINE ddrvls( DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB,
     $                   nbval, nxval, thresh, tsterr, a, copya, b,
     $                   copyb, c, s, copys, work, iwork, nout )
*
*  -- LAPACK test routine (version 3.6.0) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     November 2015
*
*     .. Scalar Arguments ..
      LOGICAL            TSTERR
      INTEGER            NM, NN, NNB, NNS, NOUT
      DOUBLE PRECISION   THRESH
*     ..
*     .. Array Arguments ..
      LOGICAL            DOTYPE( * )
      INTEGER            IWORK( * ), MVAL( * ), NBVAL( * ), NSVAL( * ),
     $                   nval( * ), nxval( * )
      DOUBLE PRECISION   A( * ), B( * ), C( * ), COPYA( * ), COPYB( * ),
     $                   copys( * ), s( * ), work( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      INTEGER            NTESTS
      parameter                ( ntests = 14 )
      INTEGER            SMLSIZ
      parameter                ( smlsiz = 25 )
      DOUBLE PRECISION   ONE, TWO, ZERO
      parameter                ( one = 1.0d0, two = 2.0d0, zero = 0.0d0 )
*     ..
*     .. Local Scalars ..
      CHARACTER          TRANS
      CHARACTER*3        PATH
      INTEGER            CRANK, I, IM, IN, INB, INFO, INS, IRANK, 
     $                   iscale, itran, itype, j, k, lda, ldb, ldwork, 
     $                   lwlsy, lwork, m, mnmin, n, nb, ncols, nerrs, 
     $                   nfail, nlvl, nrhs, nrows, nrun, rank
      DOUBLE PRECISION   EPS, NORMA, NORMB, RCOND
*     ..
*     .. Local Arrays ..
      INTEGER            ISEED( 4 ), ISEEDY( 4 )
      DOUBLE PRECISION   RESULT( ntests )
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DASUM, DLAMCH, DQRT12, DQRT14, DQRT17
      EXTERNAL           dasum, dlamch, dqrt12, dqrt14, dqrt17
*     ..
*     .. External Subroutines ..
      EXTERNAL           alaerh, alahd, alasvm, daxpy, derrls, dgels,
     $                   dgelsd, dgelss, dgelsy, dgemm, dlacpy,
     $                   dlarnv, dlasrt, dqrt13, dqrt15, dqrt16, dscal,
     $                   xlaenv
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          dble, int, log, max, min, sqrt
*     ..
*     .. Scalars in Common ..
      LOGICAL            LERR, OK
      CHARACTER*32       SRNAMT
      INTEGER            INFOT, IOUNIT
*     ..
*     .. Common blocks ..
      COMMON             / infoc / infot, iounit, ok, lerr
      COMMON             / srnamc / srnamt
*     ..
*     .. Data statements ..
      DATA               iseedy / 1988, 1989, 1990, 1991 /
*     ..
*     .. Executable Statements ..
*
*     Initialize constants and the random number seed.
*
      path( 1: 1 ) = 'Double precision'
      path( 2: 3 ) = 'LS'
      nrun = 0
      nfail = 0
      nerrs = 0
      DO 10 i = 1, 4
         iseed( i ) = iseedy( i )
   10 CONTINUE
      eps = dlamch( 'Epsilon' )
*
*     Threshold for rank estimation
*
      rcond = sqrt( eps ) - ( sqrt( eps )-eps ) / 2
*
*     Test the error exits
*
      CALL xlaenv( 2, 2 )
      CALL xlaenv( 9, smlsiz )
      IF( tsterr )
     $   CALL derrls( path, nout )
*
*     Print the header if NM = 0 or NN = 0 and THRESH = 0.
*
      IF( ( nm.EQ.0 .OR. nn.EQ.0 ) .AND. thresh.EQ.zero )
     $   CALL alahd( nout, path )
      infot = 0
      CALL xlaenv( 2, 2 )
      CALL xlaenv( 9, smlsiz )
*
      DO 150 im = 1, nm
         m = mval( im )
         lda = max( 1, m )
*
         DO 140 in = 1, nn
            n = nval( in )
            mnmin = min( m, n )
            ldb = max( 1, m, n )
*
            DO 130 ins = 1, nns
               nrhs = nsval( ins )
               nlvl = max( int( log( max( one, dble( mnmin ) ) /
     $                dble( smlsiz+1 ) ) / log( two ) ) + 1, 0 )
               lwork = max( 1, ( m+nrhs )*( n+2 ), ( n+nrhs )*( m+2 ),
     $                 m*n+4*mnmin+max( m, n ), 12*mnmin+2*mnmin*smlsiz+
     $                 8*mnmin*nlvl+mnmin*nrhs+(smlsiz+1)**2 )
*
               DO 120 irank = 1, 2
                  DO 110 iscale = 1, 3
                     itype = ( irank-1 )*3 + iscale
                     IF( .NOT.dotype( itype ) )
     $                  GO TO 110
*
                     IF( irank.EQ.1 ) THEN
*
*                       Test DGELS
*
*                       Generate a matrix of scaling type ISCALE
*
                        CALL dqrt13( iscale, m, n, copya, lda, norma,
     $                               iseed )
                        DO 40 inb = 1, nnb
                           nb = nbval( inb )
                           CALL xlaenv( 1, nb )
                           CALL xlaenv( 3, nxval( inb ) )
*
                           DO 30 itran = 1, 2
                              IF( itran.EQ.1 ) THEN
                                 trans = 'N'
                                 nrows = m
                                 ncols = n
                              ELSE
                                 trans = 'T'
                                 nrows = n
                                 ncols = m
                              END IF
                              ldwork = max( 1, ncols )
*
*                             Set up a consistent rhs
*
                              IF( ncols.GT.0 ) THEN
                                 CALL dlarnv( 2, iseed, ncols*nrhs,
     $                                        work )
                                 CALL dscal( ncols*nrhs,
     $                                       one / dble( ncols ), work,
     $                                       1 )
                              END IF
                              CALL dgemm( trans, 'No transpose', nrows,
     $                                    nrhs, ncols, one, copya, lda,
     $                                    work, ldwork, zero, b, ldb )
                              CALL dlacpy( 'Full', nrows, nrhs, b, ldb,
     $                                     copyb, ldb )
*
*                             Solve LS or overdetermined system
*
                              IF( m.GT.0 .AND. n.GT.0 ) THEN
                                 CALL dlacpy( 'Full', m, n, copya, lda,
     $                                        a, lda )
                                 CALL dlacpy( 'Full', nrows, nrhs,
     $                                        copyb, ldb, b, ldb )
                              END IF
                              srnamt = 'DGELS '
                              CALL dgels( trans, m, n, nrhs, a, lda, b,
     $                                    ldb, work, lwork, info )
                              IF( info.NE.0 )
     $                           CALL alaerh( path, 'DGELS ', info, 0,
     $                                        trans, m, n, nrhs, -1, nb,
     $                                        itype, nfail, nerrs,
     $                                        nout )
*
*                             Check correctness of results
*
                              ldwork = max( 1, nrows )
                              IF( nrows.GT.0 .AND. nrhs.GT.0 )
     $                           CALL dlacpy( 'Full', nrows, nrhs,
     $                                        copyb, ldb, c, ldb )
                              CALL dqrt16( trans, m, n, nrhs, copya,
     $                                     lda, b, ldb, c, ldb, work,
     $                                     result( 1 ) )
*
                              IF( ( itran.EQ.1 .AND. m.GE.n ) .OR.
     $                            ( itran.EQ.2 .AND. m.LT.n ) ) THEN
*
*                                Solving LS system
*
                                 result( 2 ) = dqrt17( trans, 1, m, n,
     $                                         nrhs, copya, lda, b, ldb,
     $                                         copyb, ldb, c, work,
     $                                         lwork )
                              ELSE
*
*                                Solving overdetermined system
*
                                 result( 2 ) = dqrt14( trans, m, n,
     $                                         nrhs, copya, lda, b, ldb,
     $                                         work, lwork )
                              END IF
*
*                             Print information about the tests that
*                             did not pass the threshold.
*
                              DO 20 k = 1, 2
                                 IF( result( k ).GE.thresh ) THEN
                                    IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
     $                                 CALL alahd( nout, path )
                                    WRITE( nout, fmt = 9999 )trans, m,
     $                                 n, nrhs, nb, itype, k,
     $                                 result( k )
                                    nfail = nfail + 1
                                 END IF
   20                         CONTINUE
                              nrun = nrun + 2
   30                      CONTINUE
   40                   CONTINUE
                     END IF
*
*                    Generate a matrix of scaling type ISCALE and rank
*                    type IRANK.
*
                     CALL dqrt15( iscale, irank, m, n, nrhs, copya, lda,
     $                            copyb, ldb, copys, rank, norma, normb,
     $                            iseed, work, lwork )
*
*                    workspace used: MAX(M+MIN(M,N),NRHS*MIN(M,N),2*N+M)
*
                     ldwork = max( 1, m )
*
*                    Loop for testing different block sizes.
*
                     DO 100 inb = 1, nnb
                        nb = nbval( inb )
                        CALL xlaenv( 1, nb )
                        CALL xlaenv( 3, nxval( inb ) )
*
*                       Test DGELSY
*
*                       DGELSY:  Compute the minimum-norm solution X
*                       to min( norm( A * X - B ) )
*                       using the rank-revealing orthogonal
*                       factorization.
*
*                       Initialize vector IWORK.
*
                        DO 70 j = 1, n
                           iwork( j ) = 0
   70                   CONTINUE
*
*                       Set LWLSY to the adequate value.
*
                        lwlsy = max( 1, mnmin+2*n+nb*( n+1 ),
     $                          2*mnmin+nb*nrhs )
*
                        CALL dlacpy( 'Full', m, n, copya, lda, a, lda )
                        CALL dlacpy( 'Full', m, nrhs, copyb, ldb, b,
     $                               ldb )
*
                        srnamt = 'DGELSY'
                        CALL dgelsy( m, n, nrhs, a, lda, b, ldb, iwork,
     $                               rcond, crank, work, lwlsy, info )
                        IF( info.NE.0 )
     $                     CALL alaerh( path, 'DGELSY', info, 0, ' ', m,
     $                                  n, nrhs, -1, nb, itype, nfail,
     $                                  nerrs, nout )
*
*                       Test 3:  Compute relative error in svd
*                                workspace: M*N + 4*MIN(M,N) + MAX(M,N)
*
                        result( 3 ) = dqrt12( crank, crank, a, lda,
     $                                copys, work, lwork )
*
*                       Test 4:  Compute error in solution
*                                workspace:  M*NRHS + M
*
                        CALL dlacpy( 'Full', m, nrhs, copyb, ldb, work,
     $                               ldwork )
                        CALL dqrt16( 'No transpose', m, n, nrhs, copya,
     $                               lda, b, ldb, work, ldwork,
     $                               work( m*nrhs+1 ), result( 4 ) )
*
*                       Test 5:  Check norm of r'*A
*                                workspace: NRHS*(M+N)
*
                        result( 5 ) = zero
                        IF( m.GT.crank )
     $                     result( 5 ) = dqrt17( 'No transpose', 1, m,
     $                                   n, nrhs, copya, lda, b, ldb,
     $                                   copyb, ldb, c, work, lwork )
*
*                       Test 6:  Check if x is in the rowspace of A
*                                workspace: (M+NRHS)*(N+2)
*
                        result( 6 ) = zero
*
                        IF( n.GT.crank )
     $                     result( 6 ) = dqrt14( 'No transpose', m, n,
     $                                   nrhs, copya, lda, b, ldb,
     $                                   work, lwork )
*
*                       Test DGELSS
*
*                       DGELSS:  Compute the minimum-norm solution X
*                       to min( norm( A * X - B ) )
*                       using the SVD.
*
                        CALL dlacpy( 'Full', m, n, copya, lda, a, lda )
                        CALL dlacpy( 'Full', m, nrhs, copyb, ldb, b,
     $                               ldb )
                        srnamt = 'DGELSS'
                        CALL dgelss( m, n, nrhs, a, lda, b, ldb, s,
     $                               rcond, crank, work, lwork, info )
                        IF( info.NE.0 )
     $                     CALL alaerh( path, 'DGELSS', info, 0, ' ', m,
     $                                  n, nrhs, -1, nb, itype, nfail,
     $                                  nerrs, nout )
*
*                       workspace used: 3*min(m,n) +
*                                       max(2*min(m,n),nrhs,max(m,n))
*
*                       Test 7:  Compute relative error in svd
*
                        IF( rank.GT.0 ) THEN
                           CALL daxpy( mnmin, -one, copys, 1, s, 1 )
                           result( 7 ) = dasum( mnmin, s, 1 ) /
     $                                   dasum( mnmin, copys, 1 ) /
     $                                   ( eps*dble( mnmin ) )
                        ELSE
                           result( 7 ) = zero
                        END IF
*
*                       Test 8:  Compute error in solution
*
                        CALL dlacpy( 'Full', m, nrhs, copyb, ldb, work,
     $                               ldwork )
                        CALL dqrt16( 'No transpose', m, n, nrhs, copya,
     $                               lda, b, ldb, work, ldwork,
     $                               work( m*nrhs+1 ), result( 8 ) )
*
*                       Test 9:  Check norm of r'*A
*
                        result( 9 ) = zero
                        IF( m.GT.crank )
     $                     result( 9 ) = dqrt17( 'No transpose', 1, m,
     $                                   n, nrhs, copya, lda, b, ldb,
     $                                   copyb, ldb, c, work, lwork )
*
*                       Test 10:  Check if x is in the rowspace of A
*
                        result( 10 ) = zero
                        IF( n.GT.crank )
     $                     result( 10 ) = dqrt14( 'No transpose', m, n,
     $                                    nrhs, copya, lda, b, ldb,
     $                                    work, lwork )
*
*                       Test DGELSD
*
*                       DGELSD:  Compute the minimum-norm solution X
*                       to min( norm( A * X - B ) ) using a
*                       divide and conquer SVD.
*
*                       Initialize vector IWORK.
*
                        DO 80 j = 1, n
                           iwork( j ) = 0
   80                   CONTINUE
*
                        CALL dlacpy( 'Full', m, n, copya, lda, a, lda )
                        CALL dlacpy( 'Full', m, nrhs, copyb, ldb, b,
     $                               ldb )
*
                        srnamt = 'DGELSD'
                        CALL dgelsd( m, n, nrhs, a, lda, b, ldb, s,
     $                               rcond, crank, work, lwork, iwork,
     $                               info )
                        IF( info.NE.0 )
     $                     CALL alaerh( path, 'DGELSD', info, 0, ' ', m,
     $                                  n, nrhs, -1, nb, itype, nfail,
     $                                  nerrs, nout )
*
*                       Test 11:  Compute relative error in svd
*
                        IF( rank.GT.0 ) THEN
                           CALL daxpy( mnmin, -one, copys, 1, s, 1 )
                           result( 11 ) = dasum( mnmin, s, 1 ) /
     $                                    dasum( mnmin, copys, 1 ) /
     $                                    ( eps*dble( mnmin ) )
                        ELSE
                           result( 11 ) = zero
                        END IF
*
*                       Test 12:  Compute error in solution
*
                        CALL dlacpy( 'Full', m, nrhs, copyb, ldb, work,
     $                               ldwork )
                        CALL dqrt16( 'No transpose', m, n, nrhs, copya,
     $                               lda, b, ldb, work, ldwork,
     $                               work( m*nrhs+1 ), result( 12 ) )
*
*                       Test 13:  Check norm of r'*A
*
                        result( 13 ) = zero
                        IF( m.GT.crank )
     $                     result( 13 ) = dqrt17( 'No transpose', 1, m,
     $                                    n, nrhs, copya, lda, b, ldb,
     $                                    copyb, ldb, c, work, lwork )
*
*                       Test 14:  Check if x is in the rowspace of A
*
                        result( 14 ) = zero
                        IF( n.GT.crank )
     $                     result( 14 ) = dqrt14( 'No transpose', m, n,
     $                                    nrhs, copya, lda, b, ldb,
     $                                    work, lwork )
*
*                       Print information about the tests that did not
*                       pass the threshold.
*
                        DO 90 k = 3, ntests
                           IF( result( k ).GE.thresh ) THEN
                              IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
     $                           CALL alahd( nout, path )
                              WRITE( nout, fmt = 9998 )m, n, nrhs, nb,
     $                           itype, k, result( k )
                              nfail = nfail + 1
                           END IF
   90                   CONTINUE
                        nrun = nrun + 12 
*
  100                CONTINUE
  110             CONTINUE
  120          CONTINUE
  130       CONTINUE
  140    CONTINUE
  150 CONTINUE
*
*     Print a summary of the results.
*
      CALL alasvm( path, nout, nfail, nrun, nerrs )
*
 9999 FORMAT( ' TRANS=''', a1, ''', M=', i5, ', N=', i5, ', NRHS=', i4,
     $      ', NB=', i4, ', type', i2, ', test(', i2, ')=', g12.5 )
 9998 FORMAT( ' M=', i5, ', N=', i5, ', NRHS=', i4, ', NB=', i4,
     $      ', type', i2, ', test(', i2, ')=', g12.5 )
      RETURN
*
*     End of DDRVLS
*
      END