*
* =========== DOCUMENTATION ===========
*
-* Online html documentation available at
-* http://www.netlib.org/lapack/explore-html/
+* Online html documentation available at
+* http://www.netlib.org/lapack/explore-html/
*
* Definition:
* ===========
* SUBROUTINE DCHKSY_ROOK( DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL,
* THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
* XACT, WORK, RWORK, IWORK, NOUT )
-*
+*
* .. Scalar Arguments ..
* LOGICAL TSTERR
* INTEGER NMAX, NN, NNB, NNS, NOUT
* DOUBLE PRECISION A( * ), AFAC( * ), AINV( * ), B( * ),
* $ RWORK( * ), WORK( * ), X( * ), XACT( * )
* ..
-*
+*
*
*> \par Purpose:
* =============
*>
*> \verbatim
*>
-*> DCHKSY_ROOK tests DSYTRF, -TRI_ROOK, -TRS_ROOK, -RFS_ROOK,
+*> DCHKSY_ROOK tests DSYTRF_ROOK, -TRI_ROOK, -TRS_ROOK,
*> and -CON_ROOK.
*> \endverbatim
*
* Authors:
* ========
*
-*> \author Univ. of Tennessee
-*> \author Univ. of California Berkeley
-*> \author Univ. of Colorado Denver
-*> \author NAG Ltd.
+*> \author Univ. of Tennessee
+*> \author Univ. of California Berkeley
+*> \author Univ. of Colorado Denver
+*> \author NAG Ltd.
*
*> \date November 2011
*
* =====================================================================
*
* .. Parameters ..
- DOUBLE PRECISION ZERO
- PARAMETER ( ZERO = 0.0D+0 )
+ DOUBLE PRECISION ZERO, ONE
+ PARAMETER ( ZERO = 0.0D+0, ONE = 1.0D+0 )
+ DOUBLE PRECISION EIGHT, SEVTEN
+ PARAMETER ( EIGHT = 8.0D+0, SEVTEN = 17.0D+0 )
INTEGER NTYPES
PARAMETER ( NTYPES = 10 )
INTEGER NTESTS
- PARAMETER ( NTESTS = 9 )
+ PARAMETER ( NTESTS = 7 )
* ..
* .. Local Scalars ..
LOGICAL TRFCON, ZEROT
CHARACTER DIST, TYPE, UPLO, XTYPE
- CHARACTER*3 PATH
+ CHARACTER*3 PATH, MATPATH
INTEGER I, I1, I2, IMAT, IN, INB, INFO, IOFF, IRHS,
- $ IUPLO, IZERO, J, K, KL, KU, LDA, LWORK, MODE,
- $ N, NB, NERRS, NFAIL, NIMAT, NRHS, NRUN, NT
- DOUBLE PRECISION ANORM, CNDNUM, RCOND, RCONDC
+ $ ITEMP, IUPLO, IZERO, J, K, KL, KU, LDA, LWORK,
+ $ MODE, N, NB, NERRS, NFAIL, NIMAT, NRHS, NRUN,
+ $ NT
+ DOUBLE PRECISION ALPHA, ANORM, CNDNUM, CONST, DTEMP, LAM_MAX,
+ $ LAM_MIN, RCOND, RCONDC
* ..
* .. Local Arrays ..
CHARACTER UPLOS( 2 )
- INTEGER ISEED( 4 ), ISEEDY( 4 )
- DOUBLE PRECISION RESULT( NTESTS )
+ INTEGER IDUMMY( 1 ), ISEED( 4 ), ISEEDY( 4 )
+ DOUBLE PRECISION DDUMMY( 1 ), RESULT( NTESTS )
* ..
* .. External Functions ..
- DOUBLE PRECISION DGET06, DLANSY
- EXTERNAL DGET06, DLANSY
+ DOUBLE PRECISION DGET06, DLANGE, DLANSY
+ EXTERNAL DGET06, DLANGE, DLANSY
* ..
* .. External Subroutines ..
EXTERNAL ALAERH, ALAHD, ALASUM, DERRSY, DGET04, DLACPY,
- $ DLARHS, DLATB4, DLATMS, DPOT02, DPOT03, DPOT05,
- $ DSYCON, DSYRFS, DSYT01, DSYTRF,
- $ DSYTRI2, DSYTRS, DSYTRS2, XLAENV
+ $ DLARHS, DLATB4, DLATMS, DPOT02, DPOT03, DSYEVX,
+ $ DSYCON_ROOK, DSYT01_ROOK, DSYTRF_ROOK,
+ $ DSYTRI_ROOK, DSYTRS_ROOK, XLAENV
* ..
* .. Intrinsic Functions ..
- INTRINSIC MAX, MIN
+ INTRINSIC ABS, MAX, MIN, SQRT
* ..
* .. Scalars in Common ..
LOGICAL LERR, OK
*
* Initialize constants and the random number seed.
*
+ ALPHA = ( ONE+SQRT( SEVTEN ) ) / EIGHT
+*
+* Test path
+*
PATH( 1: 1 ) = 'Double precision'
- PATH( 2: 3 ) = 'SY'
+ PATH( 2: 3 ) = 'SR'
+*
+* Path to generate matrices
+*
+ MATPATH( 1: 1 ) = 'Double precision'
+ MATPATH( 2: 3 ) = 'SY'
+*
NRUN = 0
NFAIL = 0
NERRS = 0
*
* Do for each value of N in NVAL
*
- DO 180 IN = 1, NN
+ DO 270 IN = 1, NN
N = NVAL( IN )
LDA = MAX( N, 1 )
XTYPE = 'N'
*
* Do for each value of matrix type IMAT
*
- DO 170 IMAT = 1, NIMAT
+ DO 260 IMAT = 1, NIMAT
*
* Do the tests only if DOTYPE( IMAT ) is true.
*
IF( .NOT.DOTYPE( IMAT ) )
- $ GO TO 170
+ $ GO TO 260
*
* Skip types 3, 4, 5, or 6 if the matrix size is too small.
*
ZEROT = IMAT.GE.3 .AND. IMAT.LE.6
IF( ZEROT .AND. N.LT.IMAT-2 )
- $ GO TO 170
+ $ GO TO 260
*
* Do first for UPLO = 'U', then for UPLO = 'L'
*
- DO 160 IUPLO = 1, 2
+ DO 250 IUPLO = 1, 2
UPLO = UPLOS( IUPLO )
*
-* Set up parameters with DLATB4 and generate a test matrix
-* with DLATMS.
+* Begin generate the test matrix A.
+*
+* Set up parameters with DLATB4 for the matrix generator
+* based on the type of matrix to be generated.
*
- CALL DLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE,
- $ CNDNUM, DIST )
+ CALL DLATB4( MATPATH, IMAT, N, N, TYPE, KL, KU, ANORM,
+ $ MODE, CNDNUM, DIST )
+*
+* Generate a matrix with DLATMS.
*
SRNAMT = 'DLATMS'
CALL DLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE,
$ CNDNUM, ANORM, KL, KU, UPLO, A, LDA, WORK,
$ INFO )
*
-* Check error code from DLATMS.
+* Check error code from DLATMS and handle error.
*
IF( INFO.NE.0 ) THEN
CALL ALAERH( PATH, 'DLATMS', INFO, 0, UPLO, N, N, -1,
$ -1, -1, IMAT, NFAIL, NERRS, NOUT )
- GO TO 160
+*
+* Skip all tests for this generated matrix
+*
+ GO TO 250
END IF
*
-* For types 3-6, zero one or more rows and columns of
-* the matrix to test that INFO is returned correctly.
+* For matrix types 3-6, zero one or more rows and
+* columns of the matrix to test that INFO is returned
+* correctly.
*
IF( ZEROT ) THEN
IF( IMAT.EQ.3 ) THEN
IZERO = 0
END IF
*
+* End generate the test matrix A.
+*
* Do for each value of NB in NBVAL
*
- DO 150 INB = 1, NNB
+ DO 240 INB = 1, NNB
+*
+* Set the optimal blocksize, which will be later
+* returned by ILAENV.
+*
NB = NBVAL( INB )
CALL XLAENV( 1, NB )
*
-* Compute the L*D*L' or U*D*U' factorization of the
-* matrix.
+* Copy the test matrix A into matrix AFAC which
+* will be factorized in place. This is needed to
+* preserve the test matrix A for subsequent tests.
*
CALL DLACPY( UPLO, N, N, A, LDA, AFAC, LDA )
+*
+* Compute the L*D*L**T or U*D*U**T factorization of the
+* matrix. IWORK stores details of the interchanges and
+* the block structure of D. AINV is a work array for
+* block factorization, LWORK is the length of AINV.
+*
LWORK = MAX( 2, NB )*LDA
- SRNAMT = 'DSYTRF'
- CALL DSYTRF( UPLO, N, AFAC, LDA, IWORK, AINV, LWORK,
- $ INFO )
+ SRNAMT = 'DSYTRF_ROOK'
+ CALL DSYTRF_ROOK( UPLO, N, AFAC, LDA, IWORK, AINV,
+ $ LWORK, INFO )
*
* Adjust the expected value of INFO to account for
* pivoting.
END IF
END IF
*
-* Check error code from DSYTRF.
+* Check error code from DSYTRF and handle error.
+*
+ IF( INFO.NE.K)
+ $ CALL ALAERH( PATH, 'DSYTRF_ROOK', INFO, K,
+ $ UPLO,N, N, -1, -1, NB, IMAT,
+ $ NFAIL, NERRS, NOUT )
+*
+* Set the condition estimate flag if the INFO is not 0.
*
- IF( INFO.NE.K )
- $ CALL ALAERH( PATH, 'DSYTRF', INFO, K, UPLO, N, N,
- $ -1, -1, NB, IMAT, NFAIL, NERRS, NOUT )
IF( INFO.NE.0 ) THEN
TRFCON = .TRUE.
ELSE
*+ TEST 1
* Reconstruct matrix from factors and compute residual.
*
- CALL DSYT01( UPLO, N, A, LDA, AFAC, LDA, IWORK, AINV,
- $ LDA, RWORK, RESULT( 1 ) )
+ CALL DSYT01_ROOK( UPLO, N, A, LDA, AFAC, LDA, IWORK,
+ $ AINV, LDA, RWORK, RESULT( 1 ) )
NT = 1
*
*+ TEST 2
-* Form the inverse and compute the residual.
+* Form the inverse and compute the residual,
+* if the factorization was competed without INFO > 0
+* (i.e. there is no zero rows and columns).
+* Do it only for the first block size.
*
IF( INB.EQ.1 .AND. .NOT.TRFCON ) THEN
CALL DLACPY( UPLO, N, N, AFAC, LDA, AINV, LDA )
- SRNAMT = 'DSYTRI2'
+ SRNAMT = 'DSYTRI_ROOK'
LWORK = (N+NB+1)*(NB+3)
- CALL DSYTRI2( UPLO, N, AINV, LDA, IWORK, WORK,
+ CALL DSYTRI_ROOK( UPLO, N, AINV, LDA, IWORK, WORK,
$ LWORK, INFO )
*
-* Check error code from DSYTRI2.
+* Check error code from DSYTRI_ROOK and handle error.
*
IF( INFO.NE.0 )
- $ CALL ALAERH( PATH, 'DSYTRI2', INFO, -1, UPLO, N,
- $ N, -1, -1, -1, IMAT, NFAIL, NERRS,
- $ NOUT )
+ $ CALL ALAERH( PATH, 'DSYTRI_ROOK', INFO, -1,
+ $ UPLO, N, N, -1, -1, -1, IMAT,
+ $ NFAIL, NERRS, NOUT )
+*
+* Compute the residual for a symmetric matrix times
+* its inverse.
*
CALL DPOT03( UPLO, N, A, LDA, AINV, LDA, WORK, LDA,
$ RWORK, RCONDC, RESULT( 2 ) )
110 CONTINUE
NRUN = NRUN + NT
*
+*+ TEST 3
+* Compute largest element in U or L
+*
+ RESULT( 3 ) = ZERO
+ DTEMP = ZERO
+*
+ CONST = ONE / ( ONE-ALPHA )
+*
+ IF( IUPLO.EQ.1 ) THEN
+*
+* Compute largest element in U
+*
+ K = N
+ 120 CONTINUE
+ IF( K.LE.1 )
+ $ GO TO 130
+*
+ IF( IWORK( K ).GT.ZERO ) THEN
+*
+* Get max absolute value from elements
+* in column k in in U
+*
+ DTEMP = DLANGE( 'M', K-1, 1,
+ $ AFAC( ( K-1 )*LDA+1 ), LDA, RWORK )
+ ELSE
+*
+* Get max absolute value from elements
+* in columns k and k-1 in U
+*
+ DTEMP = DLANGE( 'M', K-2, 2,
+ $ AFAC( ( K-2 )*LDA+1 ), LDA, RWORK )
+ K = K - 1
+*
+ END IF
+*
+* DTEMP should be bounded CONST
+*
+ DTEMP = DTEMP - CONST + THRESH
+ IF( DTEMP.GT.RESULT( 3 ) )
+ $ RESULT( 3 ) = DTEMP
+*
+ K = K - 1
+*
+ GO TO 120
+ 130 CONTINUE
+*
+ ELSE
+*
+* Compute largest element in L
+*
+ K = 1
+ 140 CONTINUE
+ IF( K.GE.N )
+ $ GO TO 150
+*
+ IF( IWORK( K ).GT.ZERO ) THEN
+*
+* Get max absolute value from elements
+* in column k in in L
+*
+ DTEMP = DLANGE( 'M', N-K, 1,
+ $ AFAC( ( K-1 )*LDA+K+1 ), LDA, RWORK )
+ ELSE
+*
+* Get max absolute value from elements
+* in columns k and k+1 in L
+*
+ DTEMP = DLANGE( 'M', N-K-1, 2,
+ $ AFAC( ( K-1 )*LDA+K+2 ), LDA, RWORK )
+ K = K + 1
+*
+ END IF
+*
+* DTEMP should be bounded CONST
+*
+ DTEMP = DTEMP - CONST + THRESH
+ IF( DTEMP.GT.RESULT( 3 ) )
+ $ RESULT( 3 ) = DTEMP
+*
+ K = K + 1
+*
+ GO TO 140
+ 150 CONTINUE
+ END IF
+*
+*
+*+ TEST 4
+* Compute largest 2-Norm of 2-by-2 diag blocks
+*
+ RESULT( 4 ) = ZERO
+ DTEMP = ZERO
+*
+ CONST = ( ONE+ALPHA ) / ( ONE-ALPHA )
+ CALL DLACPY( UPLO, N, N, AFAC, LDA, AINV, LDA )
+*
+ IF( IUPLO.EQ.1 ) THEN
+*
+* Loop backward for UPLO = 'U'
+*
+ K = N
+ 160 CONTINUE
+ IF( K.LE.1 )
+ $ GO TO 170
+*
+ IF( IWORK( K ).LT.ZERO ) THEN
+*
+* Get the two eigenvalues of a 2-by-2 block,
+* store them in RWORK array
+*
+ CALL DSYEVX( 'N', 'A', UPLO, 2,
+ $ AINV( ( K-2 )*LDA+K-1 ), LDA, DTEMP,
+ $ DTEMP, ITEMP, ITEMP, ZERO, ITEMP,
+ $ RWORK, DDUMMY, 1, WORK, 16,
+ $ IWORK( N+1 ), IDUMMY, INFO )
+*
+ LAM_MAX = MAX( ABS( RWORK( 1 ) ),
+ $ ABS( RWORK( 2 ) ) )
+ LAM_MIN = MIN( ABS( RWORK( 1 ) ),
+ $ ABS( RWORK( 2 ) ) )
+*
+ DTEMP = LAM_MAX / LAM_MIN
+ DTEMP = ABS( DTEMP ) - CONST + THRESH
+ IF( DTEMP.GT.RESULT( 4 ) )
+ $ RESULT( 4 ) = DTEMP
+ K = K - 1
+*
+ END IF
+*
+ K = K - 1
+*
+ GO TO 160
+ 170 CONTINUE
+*
+ ELSE
+*
+* Loop forward for UPLO = 'L'
+*
+ K = 1
+ 180 CONTINUE
+ IF( K.GE.N )
+ $ GO TO 190
+*
+ IF( IWORK( K ).LT.ZERO ) THEN
+*
+* Get the two eigenvalues of a 2-by-2 block,
+* store them in RWORK array
+*
+ CALL DSYEVX( 'N', 'A', UPLO, 2,
+ $ AINV( ( K-1 )*LDA+K ), LDA, DTEMP,
+ $ DTEMP, ITEMP, ITEMP, ZERO, ITEMP,
+ $ RWORK, DDUMMY, 1, WORK, 16,
+ $ IWORK( N+1 ), IDUMMY, INFO )
+*
+ LAM_MAX = MAX( ABS( RWORK( 1 ) ),
+ $ ABS( RWORK( 2 ) ) )
+ LAM_MIN = MIN( ABS( RWORK( 1 ) ),
+ $ ABS( RWORK( 2 ) ) )
+*
+ DTEMP = LAM_MAX / LAM_MIN
+ DTEMP = ABS( DTEMP ) - CONST + THRESH
+ IF( DTEMP.GT.RESULT( 4 ) )
+ $ RESULT( 4 ) = DTEMP
+ K = K + 1
+*
+ END IF
+*
+ K = K + 1
+*
+ GO TO 180
+ 190 CONTINUE
+ END IF
+*
+* Print information about the tests that did not pass
+* the threshold.
+*
+ DO 200 K = 3, 4
+ IF( RESULT( K ).GE.THRESH ) THEN
+ IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
+ $ CALL ALAHD( NOUT, PATH )
+ WRITE( NOUT, FMT = 9999 )UPLO, N, NB, IMAT, K,
+ $ RESULT( K )
+ NFAIL = NFAIL + 1
+ END IF
+ 200 CONTINUE
+ NRUN = NRUN + NT
+*
* Skip the other tests if this is not the first block
* size.
*
IF( INB.GT.1 )
- $ GO TO 150
+ $ GO TO 240
*
* Do only the condition estimate if INFO is not 0.
*
IF( TRFCON ) THEN
RCONDC = ZERO
- GO TO 140
+ GO TO 230
END IF
*
- DO 130 IRHS = 1, NNS
+ DO 220 IRHS = 1, NNS
NRHS = NSVAL( IRHS )
*
-*+ TEST 3 ( Using TRS)
-* Solve and compute residual for A * X = B.
-*
- SRNAMT = 'DLARHS'
- CALL DLARHS( PATH, XTYPE, UPLO, ' ', N, N, KL, KU,
- $ NRHS, A, LDA, XACT, LDA, B, LDA,
- $ ISEED, INFO )
- CALL DLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
-*
- SRNAMT = 'DSYTRS'
- CALL DSYTRS( UPLO, N, NRHS, AFAC, LDA, IWORK, X,
- $ LDA, INFO )
-*
-* Check error code from DSYTRS.
+* Begin loop over NRHS values
*
- IF( INFO.NE.0 )
- $ CALL ALAERH( PATH, 'DSYTRS', INFO, 0, UPLO, N,
- $ N, -1, -1, NRHS, IMAT, NFAIL,
- $ NERRS, NOUT )
-*
- CALL DLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA )
- CALL DPOT02( UPLO, N, NRHS, A, LDA, X, LDA, WORK,
- $ LDA, RWORK, RESULT( 3 ) )
-*
-*+ TEST 4 (Using TRS2)
*
+*+ TEST 5 ( Using TRS_ROOK)
* Solve and compute residual for A * X = B.
*
+* Choose a set of NRHS random solution vectors
+* stored in XACT and set up the right hand side B
+*
SRNAMT = 'DLARHS'
- CALL DLARHS( PATH, XTYPE, UPLO, ' ', N, N, KL, KU,
- $ NRHS, A, LDA, XACT, LDA, B, LDA,
- $ ISEED, INFO )
+ CALL DLARHS( MATPATH, XTYPE, UPLO, ' ', N, N,
+ $ KL, KU,NRHS, A, LDA, XACT, LDA,
+ $ B, LDA,ISEED, INFO )
CALL DLACPY( 'Full', N, NRHS, B, LDA, X, LDA )
*
- SRNAMT = 'DSYTRS2'
- CALL DSYTRS2( UPLO, N, NRHS, AFAC, LDA, IWORK, X,
- $ LDA, WORK, INFO )
+ SRNAMT = 'DSYTRS_ROOK'
+ CALL DSYTRS_ROOK( UPLO, N, NRHS, AFAC, LDA, IWORK,
+ $ X, LDA, INFO )
*
-* Check error code from DSYTRS2.
+* Check error code from DSYTRS_ROOK and handle error.
*
IF( INFO.NE.0 )
- $ CALL ALAERH( PATH, 'DSYTRS2', INFO, 0, UPLO, N,
- $ N, -1, -1, NRHS, IMAT, NFAIL,
- $ NERRS, NOUT )
+ $ CALL ALAERH( PATH, 'DSYTRS_ROOK', INFO, 0,
+ $ UPLO, N, N, -1, -1, NRHS, IMAT,
+ $ NFAIL, NERRS, NOUT )
*
CALL DLACPY( 'Full', N, NRHS, B, LDA, WORK, LDA )
- CALL DPOT02( UPLO, N, NRHS, A, LDA, X, LDA, WORK,
- $ LDA, RWORK, RESULT( 4 ) )
-*
-*+ TEST 5
-* Check solution from generated exact solution.
-*
- CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
- $ RESULT( 5 ) )
-*
-*+ TESTS 6, 7, and 8
-* Use iterative refinement to improve the solution.
*
- SRNAMT = 'DSYRFS'
- CALL DSYRFS( UPLO, N, NRHS, A, LDA, AFAC, LDA,
- $ IWORK, B, LDA, X, LDA, RWORK,
- $ RWORK( NRHS+1 ), WORK, IWORK( N+1 ),
- $ INFO )
+* Compute the residual for the solution
*
-* Check error code from DSYRFS.
+ CALL DPOT02( UPLO, N, NRHS, A, LDA, X, LDA, WORK,
+ $ LDA, RWORK, RESULT( 5 ) )
*
- IF( INFO.NE.0 )
- $ CALL ALAERH( PATH, 'DSYRFS', INFO, 0, UPLO, N,
- $ N, -1, -1, NRHS, IMAT, NFAIL,
- $ NERRS, NOUT )
+*+ TEST 6
+* Check solution from generated exact solution.
*
CALL DGET04( N, NRHS, X, LDA, XACT, LDA, RCONDC,
$ RESULT( 6 ) )
- CALL DPOT05( UPLO, N, NRHS, A, LDA, B, LDA, X, LDA,
- $ XACT, LDA, RWORK, RWORK( NRHS+1 ),
- $ RESULT( 7 ) )
*
* Print information about the tests that did not pass
* the threshold.
*
- DO 120 K = 3, 8
+ DO 210 K = 5, 6
IF( RESULT( K ).GE.THRESH ) THEN
IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
$ CALL ALAHD( NOUT, PATH )
$ IMAT, K, RESULT( K )
NFAIL = NFAIL + 1
END IF
- 120 CONTINUE
- NRUN = NRUN + 5
- 130 CONTINUE
+ 210 CONTINUE
+ NRUN = NRUN + 2
*
-*+ TEST 9
+* End loop over NRHS values
+*
+ 220 CONTINUE
+*
+*+ TEST 7
* Get an estimate of RCOND = 1/CNDNUM.
*
- 140 CONTINUE
+ 230 CONTINUE
ANORM = DLANSY( '1', UPLO, N, A, LDA, RWORK )
- SRNAMT = 'DSYCON'
- CALL DSYCON( UPLO, N, AFAC, LDA, IWORK, ANORM, RCOND,
- $ WORK, IWORK( N+1 ), INFO )
+ SRNAMT = 'DSYCON_ROOK'
+ CALL DSYCON_ROOK( UPLO, N, AFAC, LDA, IWORK, ANORM,
+ $ RCOND, WORK, IWORK( N+1 ), INFO )
*
-* Check error code from DSYCON.
+* Check error code from DSYCON_ROOK and handle error.
*
IF( INFO.NE.0 )
- $ CALL ALAERH( PATH, 'DSYCON', INFO, 0, UPLO, N, N,
- $ -1, -1, -1, IMAT, NFAIL, NERRS, NOUT )
+ $ CALL ALAERH( PATH, 'DSYCON_ROOK', INFO, 0,
+ $ UPLO, N, N, -1, -1, -1, IMAT,
+ $ NFAIL, NERRS, NOUT )
+*
+* Compute the test ratio to compare to values of RCOND
*
- RESULT( 9 ) = DGET06( RCOND, RCONDC )
+ RESULT( 7 ) = DGET06( RCOND, RCONDC )
*
* Print information about the tests that did not pass
* the threshold.
*
- IF( RESULT( 9 ).GE.THRESH ) THEN
+ IF( RESULT( 7 ).GE.THRESH ) THEN
IF( NFAIL.EQ.0 .AND. NERRS.EQ.0 )
$ CALL ALAHD( NOUT, PATH )
- WRITE( NOUT, FMT = 9997 )UPLO, N, IMAT, 9,
- $ RESULT( 9 )
+ WRITE( NOUT, FMT = 9997 )UPLO, N, IMAT, 7,
+ $ RESULT( 7 )
NFAIL = NFAIL + 1
END IF
NRUN = NRUN + 1
- 150 CONTINUE
+ 240 CONTINUE
*
- 160 CONTINUE
- 170 CONTINUE
- 180 CONTINUE
+ 250 CONTINUE
+ 260 CONTINUE
+ 270 CONTINUE
*
* Print a summary of the results.
*
projects / platform / upstream / lapack.git / commitdiff