TESTING/LIN/zdrvhe_aa.f

   1 *> \brief \b ZDRVHE_AA
   2 *
   3 *  =========== DOCUMENTATION ===========
   4 *
   5 * Online html documentation available at
   6 *            http://www.netlib.org/lapack/explore-html/
   7 *
   8 *  Definition:
   9 *  ===========
  10 *
  11 *       SUBROUTINE ZDRVHE_AA( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
  12 *                             A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK,
  13 *                             NOUT )
  14 *
  15 *       .. Scalar Arguments ..
  16 *       LOGICAL            TSTERR
  17 *       INTEGER            NMAX, NN, NOUT, NRHS
  18 *       DOUBLE PRECISION   THRESH
  19 *       ..
  20 *       .. Array Arguments ..
  21 *       LOGICAL            DOTYPE( * )
  22 *       INTEGER            IWORK( * ), NVAL( * )
  23 *       DOUBLE PRECISION   RWORK( * )
  24 *       COMPLEX*16         A( * ), AFAC( * ), AINV( * ), B( * ),
  25 *      $                   WORK( * ), X( * ), XACT( * )
  26 *       ..
  27 *
  28 *
  29 *> \par Purpose:
  30 *  =============
  31 *>
  32 *> \verbatim
  33 *>
  34 *> ZDRVHE_AA tests the driver routine ZHESV_AA.
  35 *> \endverbatim
  36 *
  37 *  Arguments:
  38 *  ==========
  39 *
  40 *> \param[in] DOTYPE
  41 *> \verbatim
  42 *>          DOTYPE is LOGICAL array, dimension (NTYPES)
  43 *>          The matrix types to be used for testing.  Matrices of type j
  44 *>          (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
  45 *>          .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
  46 *> \endverbatim
  47 *>
  48 *> \param[in] NN
  49 *> \verbatim
  50 *>          NN is INTEGER
  51 *>          The number of values of N contained in the vector NVAL.
  52 *> \endverbatim
  53 *>
  54 *> \param[in] NVAL
  55 *> \verbatim
  56 *>          NVAL is INTEGER array, dimension (NN)
  57 *>          The values of the matrix dimension N.
  58 *> \endverbatim
  59 *>
  60 *> \param[in] NRHS
  61 *> \verbatim
  62 *>          NRHS is INTEGER
  63 *>          The number of right hand side vectors to be generated for
  64 *>          each linear system.
  65 *> \endverbatim
  66 *>
  67 *> \param[in] THRESH
  68 *> \verbatim
  69 *>          THRESH is DOUBLE PRECISION
  70 *>          The threshold value for the test ratios.  A result is
  71 *>          included in the output file if RESULT >= THRESH.  To have
  72 *>          every test ratio printed, use THRESH = 0.
  73 *> \endverbatim
  74 *>
  75 *> \param[in] TSTERR
  76 *> \verbatim
  77 *>          TSTERR is LOGICAL
  78 *>          Flag that indicates whether error exits are to be tested.
  79 *> \endverbatim
  80 *>
  81 *> \param[in] NMAX
  82 *> \verbatim
  83 *>          NMAX is INTEGER
  84 *>          The maximum value permitted for N, used in dimensioning the
  85 *>          work arrays.
  86 *> \endverbatim
  87 *>
  88 *> \param[out] A
  89 *> \verbatim
  90 *>          A is COMPLEX*16 array, dimension (NMAX*NMAX)
  91 *> \endverbatim
  92 *>
  93 *> \param[out] AFAC
  94 *> \verbatim
  95 *>          AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
  96 *> \endverbatim
  97 *>
  98 *> \param[out] AINV
  99 *> \verbatim
 100 *>          AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
 101 *> \endverbatim
 102 *>
 103 *> \param[out] B
 104 *> \verbatim
 105 *>          B is COMPLEX*16 array, dimension (NMAX*NRHS)
 106 *> \endverbatim
 107 *>
 108 *> \param[out] X
 109 *> \verbatim
 110 *>          X is COMPLEX*16 array, dimension (NMAX*NRHS)
 111 *> \endverbatim
 112 *>
 113 *> \param[out] XACT
 114 *> \verbatim
 115 *>          XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
 116 *> \endverbatim
 117 *>
 118 *> \param[out] WORK
 119 *> \verbatim
 120 *>          WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))
 121 *> \endverbatim
 122 *>
 123 *> \param[out] RWORK
 124 *> \verbatim
 125 *>          RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
 126 *> \endverbatim
 127 *>
 128 *> \param[out] IWORK
 129 *> \verbatim
 130 *>          IWORK is INTEGER array, dimension (NMAX)
 131 *> \endverbatim
 132 *>
 133 *> \param[in] NOUT
 134 *> \verbatim
 135 *>          NOUT is INTEGER
 136 *>          The unit number for output.
 137 *> \endverbatim
 138 *
 139 *  Authors:
 140 *  ========
 141 *
 142 *> \author Univ. of Tennessee
 143 *> \author Univ. of California Berkeley
 144 *> \author Univ. of Colorado Denver
 145 *> \author NAG Ltd.
 146 *
 147 *> \date November 2016
 148 *
 149 *> \ingroup complex16_lin
 150 *
 151 *  =====================================================================
 152       SUBROUTINE ZDRVHE_AA( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR,
 153      $                         NMAX, A, AFAC, AINV, B, X, XACT, WORK,
 154      $                         RWORK, IWORK, NOUT )
 155 *
 156 *  -- LAPACK test routine (version 3.7.0) --
 157 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 158 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
 159 *     November 2016
 160 *
 161 *     .. Scalar Arguments ..
 162       LOGICAL            TSTERR
 163       INTEGER            NMAX, NN, NOUT, NRHS
 164       DOUBLE PRECISION   THRESH
 165 *     ..
 166 *     .. Array Arguments ..
 167       LOGICAL            DOTYPE( * )
 168       INTEGER            IWORK( * ), NVAL( * )
 169       DOUBLE PRECISION   RWORK( * )
 170       COMPLEX*16         A( * ), AFAC( * ), AINV( * ), B( * ),
 171      $                   WORK( * ), X( * ), XACT( * )
 172 *     ..
 173 *
 174 *  =====================================================================
 175 *
 176 *     .. Parameters ..
 177       DOUBLE PRECISION   ONE, ZERO
 178       PARAMETER          ( ONE = 1.0D+0, ZERO = 0.0D+0 )
 179       INTEGER            NTYPES, NTESTS
 180       PARAMETER          ( NTYPES = 10, NTESTS = 3 )
 181       INTEGER            NFACT
 182       PARAMETER          ( NFACT = 2 )
 183 *     ..
 184 *     .. Local Scalars ..
 185       LOGICAL            ZEROT
 186       CHARACTER          DIST, FACT, TYPE, UPLO, XTYPE
 187       CHARACTER*3        MATPATH, PATH
 188       INTEGER            I, I1, I2, IFACT, IMAT, IN, INFO, IOFF, IUPLO,
 189      $                   IZERO, J, K, KL, KU, LDA, LWORK, MODE, N,
 190      $                   NB, NBMIN, NERRS, NFAIL, NIMAT, NRUN, NT
 191       DOUBLE PRECISION   ANORM, CNDNUM, RCONDC
 192 *     ..
 193 *     .. Local Arrays ..
 194       CHARACTER          FACTS( NFACT ), UPLOS( 2 )
 195       INTEGER            ISEED( 4 ), ISEEDY( 4 )
 196       DOUBLE PRECISION   RESULT( NTESTS )
 197 *     ..
 198 *     .. External Functions ..
 199       DOUBLE PRECISION   DGET06, ZLANHE
 200       EXTERNAL           DGET06, ZLANHE
 201 *     ..
 202 *     .. External Subroutines ..
 203       EXTERNAL           ALADHD, ALAERH, ALASVM, XLAENV, ZERRVX, ZGET04,
 204      $                   ZHESV_AA, ZHET01_AA, ZHETRF_AA,
 205      $                   ZHETRI2, ZLACPY, ZLAIPD, ZLARHS, ZLATB4,
 206      $                   ZLATMS, ZPOT02
 207 *     ..
 208 *     .. Scalars in Common ..
 209       LOGICAL            LERR, OK
 210       CHARACTER*32       SRNAMT
 211       INTEGER            INFOT, NUNIT
 212 *     ..
 213 *     .. Common blocks ..
 214       COMMON             / INFOC / INFOT, NUNIT, OK, LERR
 215       COMMON             / SRNAMC / SRNAMT
 216 *     ..
 217 *     .. Intrinsic Functions ..
 218       INTRINSIC          DCMPLX, MAX, MIN
 219 *     ..
 220 *     .. Data statements ..
 221       DATA               ISEEDY / 1988, 1989, 1990, 1991 /
 222       DATA               UPLOS / 'U', 'L' / , FACTS / 'F', 'N' /
 223 *     ..
 224 *     .. Executable Statements ..
 225 *
 226 *     Initialize constants and the random number seed.
 227 *
 228 *     Test path
 229 *
 230       PATH( 1: 1 ) = 'Zomplex precision'
 231       PATH( 2: 3 ) = 'HA'
 232 *
 233 *     Path to generate matrices
 234 *
 235       MATPATH( 1: 1 ) = 'Zomplex precision'
 236       MATPATH( 2: 3 ) = 'HE'
 237 *
 238       NRUN = 0
 239       NFAIL = 0
 240       NERRS = 0
 241       DO 10 I = 1, 4
 242          ISEED( I ) = ISEEDY( I )
 243    10 CONTINUE
 244       LWORK = MAX( 2*NMAX, NMAX*NRHS )
 245 *
 246 *     Test the error exits
 247 *
 248       IF( TSTERR )
 249      $   CALL ZERRVX( PATH, NOUT )
 250       INFOT = 0
 251 *
 252 *     Set the block size and minimum block size for testing.
 253 *
 254       NB = 1
 255       NBMIN = 2
 256       CALL XLAENV( 1, NB )
 257       CALL XLAENV( 2, NBMIN )
 258 *
 259 *     Do for each value of N in NVAL
 260 *
 261       DO 180 IN = 1, NN
 262          N = NVAL( IN )
 263          LDA = MAX( N, 1 )
 264          XTYPE = 'N'
 265          NIMAT = NTYPES
 266          IF( N.LE.0 )
 267      $      NIMAT = 1
 268 *
 269          DO 170 IMAT = 1, NIMAT
 270 *
 271 *           Do the tests only if DOTYPE( IMAT ) is true.
 272 *
 273             IF( .NOT.DOTYPE( IMAT ) )
 274      $         GO TO 170
 275 *
 276 *           Skip types 3, 4, 5, or 6 if the matrix size is too small.
 277 *
 278             ZEROT = IMAT.GE.3 .AND. IMAT.LE.6
 279             IF( ZEROT .AND. N.LT.IMAT-2 )
 280      $         GO TO 170
 281 *
 282 *           Do first for UPLO = 'U', then for UPLO = 'L'
 283 *
 284             DO 160 IUPLO = 1, 2
 285                UPLO = UPLOS( IUPLO )
 286 *
 287 *              Begin generate the test matrix A.
 288 *
 289 *              Set up parameters with ZLATB4 and generate a test matrix
 290 *              with ZLATMS.
 291 *
 292                CALL ZLATB4( MATPATH, IMAT, N, N, TYPE, KL, KU, ANORM,
 293      $                       MODE, CNDNUM, DIST )
 294 *
 295                SRNAMT = 'ZLATMS'
 296                CALL ZLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE,
 297      $                      CNDNUM, ANORM, KL, KU, UPLO, A, LDA, WORK,
 298      $                      INFO )
 299 *
 300 *              Check error code from ZLATMS.
 301 *
 302                IF( INFO.NE.0 ) THEN
 303                   CALL ALAERH( PATH, 'ZLATMS', INFO, 0, UPLO, N, N, -1,
 304      $                         -1, -1, IMAT, NFAIL, NERRS, NOUT )
 305                   GO TO 160
 306                END IF
 307 *
 308 *              For types 3-6, zero one or more rows and columns of the
 309 *              matrix to test that INFO is returned correctly.
 310 *
 311                IF( ZEROT ) THEN
 312                   IF( IMAT.EQ.3 ) THEN
 313                      IZERO = 1
 314                   ELSE IF( IMAT.EQ.4 ) THEN
 315                      IZERO = N
 316                   ELSE
 317                      IZERO = N / 2 + 1
 318                   END IF
 319 *
 320                   IF( IMAT.LT.6 ) THEN
 321 *
 322 *                    Set row and column IZERO to zero.
 323 *
 324                      IF( IUPLO.EQ.1 ) THEN
 325                         IOFF = ( IZERO-1 )*LDA
 326                         DO 20 I = 1, IZERO - 1
 327                            A( IOFF+I ) = ZERO
 328    20                   CONTINUE
 329                         IOFF = IOFF + IZERO
 330                         DO 30 I = IZERO, N
 331                            A( IOFF ) = ZERO
 332                            IOFF = IOFF + LDA
 333    30                   CONTINUE
 334                      ELSE
 335                         IOFF = IZERO
 336                         DO 40 I = 1, IZERO - 1
 337                            A( IOFF ) = ZERO
 338                            IOFF = IOFF + LDA
 339    40                   CONTINUE
 340                         IOFF = IOFF - IZERO
 341                         DO 50 I = IZERO, N
 342                            A( IOFF+I ) = ZERO
 343    50                   CONTINUE
 344                      END IF
 345                   ELSE
 346                      IOFF = 0
 347                      IF( IUPLO.EQ.1 ) THEN
 348 *
 349 *                       Set the first IZERO rows and columns to zero.
 350 *
 351                         DO 70 J = 1, N
 352                            I2 = MIN( J, IZERO )
 353                            DO 60 I = 1, I2
 354                               A( IOFF+I ) = ZERO
 355    60                      CONTINUE
 356                            IOFF = IOFF + LDA
 357    70                   CONTINUE
 358                         IZERO = 1
 359                      ELSE
 360 *
 361 *                       Set the last IZERO rows and columns to zero.
 362 *
 363                         DO 90 J = 1, N
 364                            I1 = MAX( J, IZERO )
 365                            DO 80 I = I1, N
 366                               A( IOFF+I ) = ZERO
 367    80                      CONTINUE
 368                            IOFF = IOFF + LDA
 369    90                   CONTINUE
 370                      END IF
 371                   END IF
 372                ELSE
 373                   IZERO = 0
 374                END IF
 375 *
 376 *              Set the imaginary part of the diagonals.
 377 *
 378                CALL ZLAIPD( N, A, LDA+1, 0 )
 379 *
 380                DO 150 IFACT = 1, NFACT
 381 *
 382 *                 Do first for FACT = 'F', then for other values.
 383 *
 384                   FACT = FACTS( IFACT )
 385 *
 386 *                 Compute the condition number for comparison with
 387 *                 the value returned by ZHESVX.
 388 *
 389                   IF( ZEROT ) THEN
 390                      IF( IFACT.EQ.1 )
 391      $                  GO TO 150
 392                      RCONDC = ZERO
 393                   END IF
 394 *
 395 *                 Form an exact solution and set the right hand side.
 396 *
 397                   SRNAMT = 'ZLARHS'
 398                   CALL ZLARHS( MATPATH, XTYPE, UPLO, ' ', N, N, KL, KU,
 399      $                         NRHS, A, LDA, XACT, LDA, B, LDA, ISEED,
 400      $                         INFO )
 401                   XTYPE = 'C'
 402 *
 403 *                 --- Test ZHESV_AA  ---
 404 *
 405                   IF( IFACT.EQ.2 ) THEN
 406                      CALL ZLACPY( UPLO, N, N, A, LDA, AFAC, LDA )
 407                      CALL ZLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
 408 *
 409 *                    Factor the matrix and solve the system using ZHESV.
 410 *
 411                      SRNAMT = 'ZHESV_AA '
 412                      CALL ZHESV_AA( UPLO, N, NRHS, AFAC, LDA, IWORK,
 413      $                                 X, LDA, WORK, LWORK, INFO )
 414 *
 415 *                    Adjust the expected value of INFO to account for
 416 *                    pivoting.
 417 *
 418                      IF( IZERO.GT.0 ) THEN
 419                         J = 1
 420                         K = IZERO
 421   100                   CONTINUE
 422                         IF( J.EQ.K ) THEN
 423                            K = IWORK( J )
 424                         ELSE IF( IWORK( J ).EQ.K ) THEN
 425                            K = J
 426                         END IF
 427                         IF( J.LT.K ) THEN
 428                            J = J + 1
 429                            GO TO 100
 430                         END IF
 431                      ELSE
 432                         K = 0
 433                      END IF
 434 *
 435 *                    Check error code from ZHESV .
 436 *
 437                      IF( INFO.NE.K ) THEN
 438                         CALL ALAERH( PATH, 'ZHESV_AA', INFO, K, UPLO, N,
 439      $                               N, -1, -1, NRHS, IMAT, NFAIL,
 440      $                               NERRS, NOUT )
 441                         GO TO 120
 442                      ELSE IF( INFO.NE.0 ) THEN
 443                         GO TO 120
 444                      END IF
 445 *
 446 *                    Reconstruct matrix from factors and compute
 447 *                    residual.
 448 *
 449                      CALL ZHET01_AA( UPLO, N, A, LDA, AFAC, LDA,
 450      $                                  IWORK, AINV, LDA, RWORK,
 451      $                                  RESULT( 1 ) )
 452 *
 453 *                    Compute residual of the computed solution.
 454 *
 455                      CALL ZLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA )
 456                      CALL ZPOT02( UPLO, N, NRHS, A, LDA, X, LDA, WORK,
 457      $                            LDA, RWORK, RESULT( 2 ) )
 458                      NT = 2
 459 *
 460 *                    Print information about the tests that did not pass
 461 *                    the threshold.
 462 *
 463                      DO 110 K = 1, NT
 464                         IF( RESULT( K ).GE.THRESH ) THEN
 465                            IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
 466      $                        CALL ALADHD( NOUT, PATH )
 467                            WRITE( NOUT, FMT = 9999 )'ZHESV_AA', UPLO, N,
 468      $                        IMAT, K, RESULT( K )
 469                            NFAIL = NFAIL + 1
 470                         END IF
 471   110                CONTINUE
 472                      NRUN = NRUN + NT
 473   120                CONTINUE
 474                   END IF
 475 *
 476   150          CONTINUE
 477 *
 478   160       CONTINUE
 479   170    CONTINUE
 480   180 CONTINUE
 481 *
 482 *     Print a summary of the results.
 483 *
 484       CALL ALASVM( PATH, NOUT, NFAIL, NRUN, NERRS )
 485 *
 486  9999 FORMAT( 1X, A, ', UPLO=''', A1, ''', N =', I5, ', type ', I2,
 487      $      ', test ', I2, ', ratio =', G12.5 )
 488        RETURN
 489 *
 490 *     End of ZDRVHE_AA
 491 *
 492       END