1*> \brief \b CEBCHVXX 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 CEBCHVXX( THRESH, PATH ) 12* 13* .. Scalar Arguments .. 14* REAL THRESH 15* CHARACTER*3 PATH 16* .. 17* 18* Purpose 19* ====== 20* 21*> \details \b Purpose: 22*> \verbatim 23*> 24*> CEBCHVXX will run CGESVXX on a series of Hilbert matrices and then 25*> compare the error bounds returned by CGESVXX to see if the returned 26*> answer indeed falls within those bounds. 27*> 28*> Eight test ratios will be computed. The tests will pass if they are .LT. 29*> THRESH. There are two cases that are determined by 1 / (SQRT( N ) * EPS). 30*> If that value is .LE. to the component wise reciprocal condition number, 31*> it uses the guaranteed case, other wise it uses the unguaranteed case. 32*> 33*> Test ratios: 34*> Let Xc be X_computed and Xt be X_truth. 35*> The norm used is the infinity norm. 36*> 37*> Let A be the guaranteed case and B be the unguaranteed case. 38*> 39*> 1. Normwise guaranteed forward error bound. 40*> A: norm ( abs( Xc - Xt ) / norm ( Xt ) .LE. ERRBND( *, nwise_i, bnd_i ) and 41*> ERRBND( *, nwise_i, bnd_i ) .LE. MAX(SQRT(N),10) * EPS. 42*> If these conditions are met, the test ratio is set to be 43*> ERRBND( *, nwise_i, bnd_i ) / MAX(SQRT(N), 10). Otherwise it is 1/EPS. 44*> B: For this case, CGESVXX should just return 1. If it is less than 45*> one, treat it the same as in 1A. Otherwise it fails. (Set test 46*> ratio to ERRBND( *, nwise_i, bnd_i ) * THRESH?) 47*> 48*> 2. Componentwise guaranteed forward error bound. 49*> A: norm ( abs( Xc(j) - Xt(j) ) ) / norm (Xt(j)) .LE. ERRBND( *, cwise_i, bnd_i ) 50*> for all j .AND. ERRBND( *, cwise_i, bnd_i ) .LE. MAX(SQRT(N), 10) * EPS. 51*> If these conditions are met, the test ratio is set to be 52*> ERRBND( *, cwise_i, bnd_i ) / MAX(SQRT(N), 10). Otherwise it is 1/EPS. 53*> B: Same as normwise test ratio. 54*> 55*> 3. Backwards error. 56*> A: The test ratio is set to BERR/EPS. 57*> B: Same test ratio. 58*> 59*> 4. Reciprocal condition number. 60*> A: A condition number is computed with Xt and compared with the one 61*> returned from CGESVXX. Let RCONDc be the RCOND returned by CGESVXX 62*> and RCONDt be the RCOND from the truth value. Test ratio is set to 63*> MAX(RCONDc/RCONDt, RCONDt/RCONDc). 64*> B: Test ratio is set to 1 / (EPS * RCONDc). 65*> 66*> 5. Reciprocal normwise condition number. 67*> A: The test ratio is set to 68*> MAX(ERRBND( *, nwise_i, cond_i ) / NCOND, NCOND / ERRBND( *, nwise_i, cond_i )). 69*> B: Test ratio is set to 1 / (EPS * ERRBND( *, nwise_i, cond_i )). 70*> 71*> 6. Reciprocal componentwise condition number. 72*> A: Test ratio is set to 73*> MAX(ERRBND( *, cwise_i, cond_i ) / CCOND, CCOND / ERRBND( *, cwise_i, cond_i )). 74*> B: Test ratio is set to 1 / (EPS * ERRBND( *, cwise_i, cond_i )). 75*> 76*> .. Parameters .. 77*> NMAX is determined by the largest number in the inverse of the hilbert 78*> matrix. Precision is exhausted when the largest entry in it is greater 79*> than 2 to the power of the number of bits in the fraction of the data 80*> type used plus one, which is 24 for single precision. 81*> NMAX should be 6 for single and 11 for double. 82*> \endverbatim 83* 84* Authors: 85* ======== 86* 87*> \author Univ. of Tennessee 88*> \author Univ. of California Berkeley 89*> \author Univ. of Colorado Denver 90*> \author NAG Ltd. 91* 92*> \date December 2016 93* 94*> \ingroup complex_lin 95* 96* ===================================================================== 97 SUBROUTINE CEBCHVXX( THRESH, PATH ) 98 IMPLICIT NONE 99* .. Scalar Arguments .. 100 REAL THRESH 101 CHARACTER*3 PATH 102 103 INTEGER NMAX, NPARAMS, NERRBND, NTESTS, KL, KU 104 PARAMETER (NMAX = 6, NPARAMS = 2, NERRBND = 3, 105 $ NTESTS = 6) 106 107* .. Local Scalars .. 108 INTEGER N, NRHS, INFO, I ,J, k, NFAIL, LDA, 109 $ N_AUX_TESTS, LDAB, LDAFB 110 CHARACTER FACT, TRANS, UPLO, EQUED 111 CHARACTER*2 C2 112 CHARACTER(3) NGUAR, CGUAR 113 LOGICAL printed_guide 114 REAL NCOND, CCOND, M, NORMDIF, NORMT, RCOND, 115 $ RNORM, RINORM, SUMR, SUMRI, EPS, 116 $ BERR(NMAX), RPVGRW, ORCOND, 117 $ CWISE_ERR, NWISE_ERR, CWISE_BND, NWISE_BND, 118 $ CWISE_RCOND, NWISE_RCOND, 119 $ CONDTHRESH, ERRTHRESH 120 COMPLEX ZDUM 121 122* .. Local Arrays .. 123 REAL TSTRAT(NTESTS), RINV(NMAX), PARAMS(NPARAMS), 124 $ S(NMAX), R(NMAX),C(NMAX),RWORK(3*NMAX), 125 $ DIFF(NMAX, NMAX), 126 $ ERRBND_N(NMAX*3), ERRBND_C(NMAX*3) 127 INTEGER IPIV(NMAX) 128 COMPLEX A(NMAX,NMAX),INVHILB(NMAX,NMAX),X(NMAX,NMAX), 129 $ WORK(NMAX*3*5), AF(NMAX, NMAX),B(NMAX, NMAX), 130 $ ACOPY(NMAX, NMAX), 131 $ AB( (NMAX-1)+(NMAX-1)+1, NMAX ), 132 $ ABCOPY( (NMAX-1)+(NMAX-1)+1, NMAX ), 133 $ AFB( 2*(NMAX-1)+(NMAX-1)+1, NMAX ) 134 135* .. External Functions .. 136 REAL SLAMCH 137 138* .. External Subroutines .. 139 EXTERNAL CLAHILB, CGESVXX, CSYSVXX, CPOSVXX, 140 $ CGBSVXX, CLACPY, LSAMEN 141 LOGICAL LSAMEN 142 143* .. Intrinsic Functions .. 144 INTRINSIC SQRT, MAX, ABS, REAL, AIMAG 145 146* .. Statement Functions .. 147 REAL CABS1 148* .. 149* .. Statement Function Definitions .. 150 CABS1( ZDUM ) = ABS( REAL( ZDUM ) ) + ABS( AIMAG( ZDUM ) ) 151 152* .. Parameters .. 153 INTEGER NWISE_I, CWISE_I 154 PARAMETER (NWISE_I = 1, CWISE_I = 1) 155 INTEGER BND_I, COND_I 156 PARAMETER (BND_I = 2, COND_I = 3) 157 158* Create the loop to test out the Hilbert matrices 159 160 FACT = 'E' 161 UPLO = 'U' 162 TRANS = 'N' 163 EQUED = 'N' 164 EPS = SLAMCH('Epsilon') 165 NFAIL = 0 166 N_AUX_TESTS = 0 167 LDA = NMAX 168 LDAB = (NMAX-1)+(NMAX-1)+1 169 LDAFB = 2*(NMAX-1)+(NMAX-1)+1 170 C2 = PATH( 2: 3 ) 171 172* Main loop to test the different Hilbert Matrices. 173 174 printed_guide = .false. 175 176 DO N = 1 , NMAX 177 PARAMS(1) = -1 178 PARAMS(2) = -1 179 180 KL = N-1 181 KU = N-1 182 NRHS = n 183 M = MAX(SQRT(REAL(N)), 10.0) 184 185* Generate the Hilbert matrix, its inverse, and the 186* right hand side, all scaled by the LCM(1,..,2N-1). 187 CALL CLAHILB(N, N, A, LDA, INVHILB, LDA, B, 188 $ LDA, WORK, INFO, PATH) 189 190* Copy A into ACOPY. 191 CALL CLACPY('ALL', N, N, A, NMAX, ACOPY, NMAX) 192 193* Store A in band format for GB tests 194 DO J = 1, N 195 DO I = 1, KL+KU+1 196 AB( I, J ) = (0.0E+0,0.0E+0) 197 END DO 198 END DO 199 DO J = 1, N 200 DO I = MAX( 1, J-KU ), MIN( N, J+KL ) 201 AB( KU+1+I-J, J ) = A( I, J ) 202 END DO 203 END DO 204 205* Copy AB into ABCOPY. 206 DO J = 1, N 207 DO I = 1, KL+KU+1 208 ABCOPY( I, J ) = (0.0E+0,0.0E+0) 209 END DO 210 END DO 211 CALL CLACPY('ALL', KL+KU+1, N, AB, LDAB, ABCOPY, LDAB) 212 213* Call C**SVXX with default PARAMS and N_ERR_BND = 3. 214 IF ( LSAMEN( 2, C2, 'SY' ) ) THEN 215 CALL CSYSVXX(FACT, UPLO, N, NRHS, ACOPY, LDA, AF, LDA, 216 $ IPIV, EQUED, S, B, LDA, X, LDA, ORCOND, 217 $ RPVGRW, BERR, NERRBND, ERRBND_N, ERRBND_C, NPARAMS, 218 $ PARAMS, WORK, RWORK, INFO) 219 ELSE IF ( LSAMEN( 2, C2, 'PO' ) ) THEN 220 CALL CPOSVXX(FACT, UPLO, N, NRHS, ACOPY, LDA, AF, LDA, 221 $ EQUED, S, B, LDA, X, LDA, ORCOND, 222 $ RPVGRW, BERR, NERRBND, ERRBND_N, ERRBND_C, NPARAMS, 223 $ PARAMS, WORK, RWORK, INFO) 224 ELSE IF ( LSAMEN( 2, C2, 'HE' ) ) THEN 225 CALL CHESVXX(FACT, UPLO, N, NRHS, ACOPY, LDA, AF, LDA, 226 $ IPIV, EQUED, S, B, LDA, X, LDA, ORCOND, 227 $ RPVGRW, BERR, NERRBND, ERRBND_N, ERRBND_C, NPARAMS, 228 $ PARAMS, WORK, RWORK, INFO) 229 ELSE IF ( LSAMEN( 2, C2, 'GB' ) ) THEN 230 CALL CGBSVXX(FACT, TRANS, N, KL, KU, NRHS, ABCOPY, 231 $ LDAB, AFB, LDAFB, IPIV, EQUED, R, C, B, 232 $ LDA, X, LDA, ORCOND, RPVGRW, BERR, NERRBND, 233 $ ERRBND_N, ERRBND_C, NPARAMS, PARAMS, WORK, RWORK, 234 $ INFO) 235 ELSE 236 CALL CGESVXX(FACT, TRANS, N, NRHS, ACOPY, LDA, AF, LDA, 237 $ IPIV, EQUED, R, C, B, LDA, X, LDA, ORCOND, 238 $ RPVGRW, BERR, NERRBND, ERRBND_N, ERRBND_C, NPARAMS, 239 $ PARAMS, WORK, RWORK, INFO) 240 END IF 241 242 N_AUX_TESTS = N_AUX_TESTS + 1 243 IF (ORCOND .LT. EPS) THEN 244! Either factorization failed or the matrix is flagged, and 1 <= 245! INFO <= N+1. We don't decide based on rcond anymore. 246! IF (INFO .EQ. 0 .OR. INFO .GT. N+1) THEN 247! NFAIL = NFAIL + 1 248! WRITE (*, FMT=8000) N, INFO, ORCOND, RCOND 249! END IF 250 ELSE 251! Either everything succeeded (INFO == 0) or some solution failed 252! to converge (INFO > N+1). 253 IF (INFO .GT. 0 .AND. INFO .LE. N+1) THEN 254 NFAIL = NFAIL + 1 255 WRITE (*, FMT=8000) C2, N, INFO, ORCOND, RCOND 256 END IF 257 END IF 258 259* Calculating the difference between C**SVXX's X and the true X. 260 DO I = 1,N 261 DO J =1,NRHS 262 DIFF(I,J) = X(I,J) - INVHILB(I,J) 263 END DO 264 END DO 265 266* Calculating the RCOND 267 RNORM = 0 268 RINORM = 0 269 IF ( LSAMEN( 2, C2, 'PO' ) .OR. LSAMEN( 2, C2, 'SY' ) .OR. 270 $ LSAMEN( 2, C2, 'HE' ) ) THEN 271 DO I = 1, N 272 SUMR = 0 273 SUMRI = 0 274 DO J = 1, N 275 SUMR = SUMR + S(I) * CABS1(A(I,J)) * S(J) 276 SUMRI = SUMRI + CABS1(INVHILB(I, J)) / (S(J) * S(I)) 277 END DO 278 RNORM = MAX(RNORM,SUMR) 279 RINORM = MAX(RINORM,SUMRI) 280 END DO 281 ELSE IF ( LSAMEN( 2, C2, 'GE' ) .OR. LSAMEN( 2, C2, 'GB' ) ) 282 $ THEN 283 DO I = 1, N 284 SUMR = 0 285 SUMRI = 0 286 DO J = 1, N 287 SUMR = SUMR + R(I) * CABS1(A(I,J)) * C(J) 288 SUMRI = SUMRI + CABS1(INVHILB(I, J)) / (R(J) * C(I)) 289 END DO 290 RNORM = MAX(RNORM,SUMR) 291 RINORM = MAX(RINORM,SUMRI) 292 END DO 293 END IF 294 295 RNORM = RNORM / CABS1(A(1, 1)) 296 RCOND = 1.0/(RNORM * RINORM) 297 298* Calculating the R for normwise rcond. 299 DO I = 1, N 300 RINV(I) = 0.0 301 END DO 302 DO J = 1, N 303 DO I = 1, N 304 RINV(I) = RINV(I) + CABS1(A(I,J)) 305 END DO 306 END DO 307 308* Calculating the Normwise rcond. 309 RINORM = 0.0 310 DO I = 1, N 311 SUMRI = 0.0 312 DO J = 1, N 313 SUMRI = SUMRI + CABS1(INVHILB(I,J) * RINV(J)) 314 END DO 315 RINORM = MAX(RINORM, SUMRI) 316 END DO 317 318! invhilb is the inverse *unscaled* Hilbert matrix, so scale its norm 319! by 1/A(1,1) to make the scaling match A (the scaled Hilbert matrix) 320 NCOND = CABS1(A(1,1)) / RINORM 321 322 CONDTHRESH = M * EPS 323 ERRTHRESH = M * EPS 324 325 DO K = 1, NRHS 326 NORMT = 0.0 327 NORMDIF = 0.0 328 CWISE_ERR = 0.0 329 DO I = 1, N 330 NORMT = MAX(CABS1(INVHILB(I, K)), NORMT) 331 NORMDIF = MAX(CABS1(X(I,K) - INVHILB(I,K)), NORMDIF) 332 IF (INVHILB(I,K) .NE. 0.0) THEN 333 CWISE_ERR = MAX(CABS1(X(I,K) - INVHILB(I,K)) 334 $ /CABS1(INVHILB(I,K)), CWISE_ERR) 335 ELSE IF (X(I, K) .NE. 0.0) THEN 336 CWISE_ERR = SLAMCH('OVERFLOW') 337 END IF 338 END DO 339 IF (NORMT .NE. 0.0) THEN 340 NWISE_ERR = NORMDIF / NORMT 341 ELSE IF (NORMDIF .NE. 0.0) THEN 342 NWISE_ERR = SLAMCH('OVERFLOW') 343 ELSE 344 NWISE_ERR = 0.0 345 ENDIF 346 347 DO I = 1, N 348 RINV(I) = 0.0 349 END DO 350 DO J = 1, N 351 DO I = 1, N 352 RINV(I) = RINV(I) + CABS1(A(I, J) * INVHILB(J, K)) 353 END DO 354 END DO 355 RINORM = 0.0 356 DO I = 1, N 357 SUMRI = 0.0 358 DO J = 1, N 359 SUMRI = SUMRI 360 $ + CABS1(INVHILB(I, J) * RINV(J) / INVHILB(I, K)) 361 END DO 362 RINORM = MAX(RINORM, SUMRI) 363 END DO 364! invhilb is the inverse *unscaled* Hilbert matrix, so scale its norm 365! by 1/A(1,1) to make the scaling match A (the scaled Hilbert matrix) 366 CCOND = CABS1(A(1,1))/RINORM 367 368! Forward error bound tests 369 NWISE_BND = ERRBND_N(K + (BND_I-1)*NRHS) 370 CWISE_BND = ERRBND_C(K + (BND_I-1)*NRHS) 371 NWISE_RCOND = ERRBND_N(K + (COND_I-1)*NRHS) 372 CWISE_RCOND = ERRBND_C(K + (COND_I-1)*NRHS) 373! write (*,*) 'nwise : ', n, k, ncond, nwise_rcond, 374! $ condthresh, ncond.ge.condthresh 375! write (*,*) 'nwise2: ', k, nwise_bnd, nwise_err, errthresh 376 IF (NCOND .GE. CONDTHRESH) THEN 377 NGUAR = 'YES' 378 IF (NWISE_BND .GT. ERRTHRESH) THEN 379 TSTRAT(1) = 1/(2.0*EPS) 380 ELSE 381 IF (NWISE_BND .NE. 0.0) THEN 382 TSTRAT(1) = NWISE_ERR / NWISE_BND 383 ELSE IF (NWISE_ERR .NE. 0.0) THEN 384 TSTRAT(1) = 1/(16.0*EPS) 385 ELSE 386 TSTRAT(1) = 0.0 387 END IF 388 IF (TSTRAT(1) .GT. 1.0) THEN 389 TSTRAT(1) = 1/(4.0*EPS) 390 END IF 391 END IF 392 ELSE 393 NGUAR = 'NO' 394 IF (NWISE_BND .LT. 1.0) THEN 395 TSTRAT(1) = 1/(8.0*EPS) 396 ELSE 397 TSTRAT(1) = 1.0 398 END IF 399 END IF 400! write (*,*) 'cwise : ', n, k, ccond, cwise_rcond, 401! $ condthresh, ccond.ge.condthresh 402! write (*,*) 'cwise2: ', k, cwise_bnd, cwise_err, errthresh 403 IF (CCOND .GE. CONDTHRESH) THEN 404 CGUAR = 'YES' 405 IF (CWISE_BND .GT. ERRTHRESH) THEN 406 TSTRAT(2) = 1/(2.0*EPS) 407 ELSE 408 IF (CWISE_BND .NE. 0.0) THEN 409 TSTRAT(2) = CWISE_ERR / CWISE_BND 410 ELSE IF (CWISE_ERR .NE. 0.0) THEN 411 TSTRAT(2) = 1/(16.0*EPS) 412 ELSE 413 TSTRAT(2) = 0.0 414 END IF 415 IF (TSTRAT(2) .GT. 1.0) TSTRAT(2) = 1/(4.0*EPS) 416 END IF 417 ELSE 418 CGUAR = 'NO' 419 IF (CWISE_BND .LT. 1.0) THEN 420 TSTRAT(2) = 1/(8.0*EPS) 421 ELSE 422 TSTRAT(2) = 1.0 423 END IF 424 END IF 425 426! Backwards error test 427 TSTRAT(3) = BERR(K)/EPS 428 429! Condition number tests 430 TSTRAT(4) = RCOND / ORCOND 431 IF (RCOND .GE. CONDTHRESH .AND. TSTRAT(4) .LT. 1.0) 432 $ TSTRAT(4) = 1.0 / TSTRAT(4) 433 434 TSTRAT(5) = NCOND / NWISE_RCOND 435 IF (NCOND .GE. CONDTHRESH .AND. TSTRAT(5) .LT. 1.0) 436 $ TSTRAT(5) = 1.0 / TSTRAT(5) 437 438 TSTRAT(6) = CCOND / NWISE_RCOND 439 IF (CCOND .GE. CONDTHRESH .AND. TSTRAT(6) .LT. 1.0) 440 $ TSTRAT(6) = 1.0 / TSTRAT(6) 441 442 DO I = 1, NTESTS 443 IF (TSTRAT(I) .GT. THRESH) THEN 444 IF (.NOT.PRINTED_GUIDE) THEN 445 WRITE(*,*) 446 WRITE( *, 9996) 1 447 WRITE( *, 9995) 2 448 WRITE( *, 9994) 3 449 WRITE( *, 9993) 4 450 WRITE( *, 9992) 5 451 WRITE( *, 9991) 6 452 WRITE( *, 9990) 7 453 WRITE( *, 9989) 8 454 WRITE(*,*) 455 PRINTED_GUIDE = .TRUE. 456 END IF 457 WRITE( *, 9999) C2, N, K, NGUAR, CGUAR, I, TSTRAT(I) 458 NFAIL = NFAIL + 1 459 END IF 460 END DO 461 END DO 462 463c$$$ WRITE(*,*) 464c$$$ WRITE(*,*) 'Normwise Error Bounds' 465c$$$ WRITE(*,*) 'Guaranteed error bound: ',ERRBND(NRHS,nwise_i,bnd_i) 466c$$$ WRITE(*,*) 'Reciprocal condition number: ',ERRBND(NRHS,nwise_i,cond_i) 467c$$$ WRITE(*,*) 'Raw error estimate: ',ERRBND(NRHS,nwise_i,rawbnd_i) 468c$$$ WRITE(*,*) 469c$$$ WRITE(*,*) 'Componentwise Error Bounds' 470c$$$ WRITE(*,*) 'Guaranteed error bound: ',ERRBND(NRHS,cwise_i,bnd_i) 471c$$$ WRITE(*,*) 'Reciprocal condition number: ',ERRBND(NRHS,cwise_i,cond_i) 472c$$$ WRITE(*,*) 'Raw error estimate: ',ERRBND(NRHS,cwise_i,rawbnd_i) 473c$$$ print *, 'Info: ', info 474c$$$ WRITE(*,*) 475* WRITE(*,*) 'TSTRAT: ',TSTRAT 476 477 END DO 478 479 WRITE(*,*) 480 IF( NFAIL .GT. 0 ) THEN 481 WRITE(*,9998) C2, NFAIL, NTESTS*N+N_AUX_TESTS 482 ELSE 483 WRITE(*,9997) C2 484 END IF 485 9999 FORMAT( ' C', A2, 'SVXX: N =', I2, ', RHS = ', I2, 486 $ ', NWISE GUAR. = ', A, ', CWISE GUAR. = ', A, 487 $ ' test(',I1,') =', G12.5 ) 488 9998 FORMAT( ' C', A2, 'SVXX: ', I6, ' out of ', I6, 489 $ ' tests failed to pass the threshold' ) 490 9997 FORMAT( ' C', A2, 'SVXX passed the tests of error bounds' ) 491* Test ratios. 492 9996 FORMAT( 3X, I2, ': Normwise guaranteed forward error', / 5X, 493 $ 'Guaranteed case: if norm ( abs( Xc - Xt )', 494 $ ' / norm ( Xt ) .LE. ERRBND( *, nwise_i, bnd_i ), then', 495 $ / 5X, 496 $ 'ERRBND( *, nwise_i, bnd_i ) .LE. MAX(SQRT(N), 10) * EPS') 497 9995 FORMAT( 3X, I2, ': Componentwise guaranteed forward error' ) 498 9994 FORMAT( 3X, I2, ': Backwards error' ) 499 9993 FORMAT( 3X, I2, ': Reciprocal condition number' ) 500 9992 FORMAT( 3X, I2, ': Reciprocal normwise condition number' ) 501 9991 FORMAT( 3X, I2, ': Raw normwise error estimate' ) 502 9990 FORMAT( 3X, I2, ': Reciprocal componentwise condition number' ) 503 9989 FORMAT( 3X, I2, ': Raw componentwise error estimate' ) 504 505 8000 FORMAT( ' C', A2, 'SVXX: N =', I2, ', INFO = ', I3, 506 $ ', ORCOND = ', G12.5, ', real RCOND = ', G12.5 ) 507 508 END 509