OpenRadioss 2025.1.11
OpenRadioss project
Loading...
Searching...
No Matches
zdrvge.f
Go to the documentation of this file.
1*> \brief \b ZDRVGE
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 ZDRVGE( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
12* A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK,
13* RWORK, IWORK, 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( * ), S( * )
24* COMPLEX*16 A( * ), AFAC( * ), ASAV( * ), B( * ),
25* $ BSAV( * ), WORK( * ), X( * ), XACT( * )
26* ..
27*
28*
29*> \par Purpose:
30* =============
31*>
32*> \verbatim
33*>
34*> ZDRVGE tests the driver routines ZGESV and -SVX.
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 column 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] ASAV
99*> \verbatim
100*> ASAV 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] BSAV
109*> \verbatim
110*> BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
111*> \endverbatim
112*>
113*> \param[out] X
114*> \verbatim
115*> X is COMPLEX*16 array, dimension (NMAX*NRHS)
116*> \endverbatim
117*>
118*> \param[out] XACT
119*> \verbatim
120*> XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
121*> \endverbatim
122*>
123*> \param[out] S
124*> \verbatim
125*> S is DOUBLE PRECISION array, dimension (2*NMAX)
126*> \endverbatim
127*>
128*> \param[out] WORK
129*> \verbatim
130*> WORK is COMPLEX*16 array, dimension
131*> (NMAX*max(3,NRHS))
132*> \endverbatim
133*>
134*> \param[out] RWORK
135*> \verbatim
136*> RWORK is DOUBLE PRECISION array, dimension (2*NRHS+NMAX)
137*> \endverbatim
138*>
139*> \param[out] IWORK
140*> \verbatim
141*> IWORK is INTEGER array, dimension (NMAX)
142*> \endverbatim
143*>
144*> \param[in] NOUT
145*> \verbatim
146*> NOUT is INTEGER
147*> The unit number for output.
148*> \endverbatim
149*
150* Authors:
151* ========
152*
153*> \author Univ. of Tennessee
154*> \author Univ. of California Berkeley
155*> \author Univ. of Colorado Denver
156*> \author NAG Ltd.
157*
158*> \ingroup complex16_lin
159*
160* =====================================================================
161 SUBROUTINE zdrvge( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
162 $ A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK,
163 $ RWORK, IWORK, NOUT )
164*
165* -- LAPACK test routine --
166* -- LAPACK is a software package provided by Univ. of Tennessee, --
167* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
168*
169* .. Scalar Arguments ..
170 LOGICAL TSTERR
171 INTEGER NMAX, NN, NOUT, NRHS
172 DOUBLE PRECISION THRESH
173* ..
174* .. Array Arguments ..
175 LOGICAL DOTYPE( * )
176 INTEGER IWORK( * ), NVAL( * )
177 DOUBLE PRECISION RWORK( * ), S( * )
178 COMPLEX*16 A( * ), AFAC( * ), ASAV( * ), B( * ),
179 $ bsav( * ), work( * ), x( * ), xact( * )
180* ..
181*
182* =====================================================================
183*
184* .. Parameters ..
185 DOUBLE PRECISION ONE, ZERO
186 PARAMETER ( ONE = 1.0d+0, zero = 0.0d+0 )
187 INTEGER NTYPES
188 PARAMETER ( ntypes = 11 )
189 INTEGER NTESTS
190 parameter( ntests = 7 )
191 INTEGER NTRAN
192 parameter( ntran = 3 )
193* ..
194* .. Local Scalars ..
195 LOGICAL EQUIL, NOFACT, PREFAC, TRFCON, ZEROT
196 CHARACTER DIST, EQUED, FACT, TRANS, TYPE, XTYPE
197 CHARACTER*3 PATH
198 INTEGER I, IEQUED, IFACT, IMAT, IN, INFO, IOFF, ITRAN,
199 $ izero, k, k1, kl, ku, lda, lwork, mode, n, nb,
200 $ nbmin, nerrs, nfact, nfail, nimat, nrun, nt
201 DOUBLE PRECISION AINVNM, AMAX, ANORM, ANORMI, ANORMO, CNDNUM,
202 $ COLCND, RCOND, RCONDC, RCONDI, RCONDO, ROLDC,
203 $ roldi, roldo, rowcnd, rpvgrw
204* ..
205* .. Local Arrays ..
206 CHARACTER EQUEDS( 4 ), FACTS( 3 ), TRANSS( NTRAN )
207 INTEGER ISEED( 4 ), ISEEDY( 4 )
208 DOUBLE PRECISION RDUM( 1 ), RESULT( NTESTS )
209* ..
210* .. External Functions ..
211 LOGICAL LSAME
212 DOUBLE PRECISION DGET06, DLAMCH, ZLANGE, ZLANTR
213 EXTERNAL lsame, dget06, dlamch, zlange, zlantr
214* ..
215* .. External Subroutines ..
216 EXTERNAL aladhd, alaerh, alasvm, xlaenv, zerrvx, zgeequ,
217 $ zgesv, zgesvx, zget01, zget02, zget04, zget07,
218 $ zgetrf, zgetri, zlacpy, zlaqge, zlarhs, zlaset,
219 $ zlatb4, zlatms
220* ..
221* .. Intrinsic Functions ..
222 INTRINSIC abs, dcmplx, max
223* ..
224* .. Scalars in Common ..
225 LOGICAL LERR, OK
226 CHARACTER*32 SRNAMT
227 INTEGER INFOT, NUNIT
228* ..
229* .. Common blocks ..
230 COMMON / infoc / infot, nunit, ok, lerr
231 COMMON / srnamc / srnamt
232* ..
233* .. Data statements ..
234 DATA iseedy / 1988, 1989, 1990, 1991 /
235 DATA transs / 'N', 'T', 'C' /
236 DATA facts / 'f', 'n', 'e' /
237 DATA EQUEDS / 'n', 'r', 'c', 'b' /
238* ..
239* .. Executable Statements ..
240*
241* Initialize constants and the random number seed.
242*
243 PATH( 1: 1 ) = 'zomplex precision'
244 PATH( 2: 3 ) = 'ge'
245 NRUN = 0
246 NFAIL = 0
247 NERRS = 0
248 DO 10 I = 1, 4
249 ISEED( I ) = ISEEDY( I )
250 10 CONTINUE
251*
252* Test the error exits
253*
254 IF( TSTERR )
255 $ CALL ZERRVX( PATH, NOUT )
256 INFOT = 0
257*
258* Set the block size and minimum block size for testing.
259*
260 NB = 1
261 NBMIN = 2
262 CALL XLAENV( 1, NB )
263 CALL XLAENV( 2, NBMIN )
264*
265* Do for each value of N in NVAL
266*
267 DO 90 IN = 1, NN
268 N = NVAL( IN )
269 LDA = MAX( N, 1 )
270 XTYPE = 'n'
271 NIMAT = NTYPES
272.LE. IF( N0 )
273 $ NIMAT = 1
274*
275 DO 80 IMAT = 1, NIMAT
276*
277* Do the tests only if DOTYPE( IMAT ) is true.
278*
279.NOT. IF( DOTYPE( IMAT ) )
280 $ GO TO 80
281*
282* Skip types 5, 6, or 7 if the matrix size is too small.
283*
284.GE..AND..LE. ZEROT = IMAT5 IMAT7
285.AND..LT. IF( ZEROT NIMAT-4 )
286 $ GO TO 80
287*
288* Set up parameters with ZLATB4 and generate a test matrix
289* with ZLATMS.
290*
291 CALL ZLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE,
292 $ CNDNUM, DIST )
293 RCONDC = ONE / CNDNUM
294*
295 SRNAMT = 'zlatms'
296 CALL ZLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE, CNDNUM,
297 $ ANORM, KL, KU, 'no packing', A, LDA, WORK,
298 $ INFO )
299*
300* Check error code from ZLATMS.
301*
302.NE. IF( INFO0 ) THEN
303 CALL ALAERH( PATH, 'zlatms', INFO, 0, ' ', N, N, -1, -1,
304 $ -1, IMAT, NFAIL, NERRS, NOUT )
305 GO TO 80
306 END IF
307*
308* For types 5-7, zero one or more columns of the matrix to
309* test that INFO is returned correctly.
310*
311 IF( ZEROT ) THEN
312.EQ. IF( IMAT5 ) THEN
313 IZERO = 1
314.EQ. ELSE IF( IMAT6 ) THEN
315 IZERO = N
316 ELSE
317 IZERO = N / 2 + 1
318 END IF
319 IOFF = ( IZERO-1 )*LDA
320.LT. IF( IMAT7 ) THEN
321 DO 20 I = 1, N
322 A( IOFF+I ) = ZERO
323 20 CONTINUE
324 ELSE
325 CALL ZLASET( 'full', N, N-IZERO+1, DCMPLX( ZERO ),
326 $ DCMPLX( ZERO ), A( IOFF+1 ), LDA )
327 END IF
328 ELSE
329 IZERO = 0
330 END IF
331*
332* Save a copy of the matrix A in ASAV.
333*
334 CALL ZLACPY( 'full', N, N, A, LDA, ASAV, LDA )
335*
336 DO 70 IEQUED = 1, 4
337 EQUED = EQUEDS( IEQUED )
338.EQ. IF( IEQUED1 ) THEN
339 NFACT = 3
340 ELSE
341 NFACT = 1
342 END IF
343*
344 DO 60 IFACT = 1, NFACT
345 FACT = FACTS( IFACT )
346 PREFAC = LSAME( FACT, 'f' )
347 NOFACT = LSAME( FACT, 'n' )
348 EQUIL = LSAME( FACT, 'e' )
349*
350 IF( ZEROT ) THEN
351 IF( PREFAC )
352 $ GO TO 60
353 RCONDO = ZERO
354 RCONDI = ZERO
355*
356.NOT. ELSE IF( NOFACT ) THEN
357*
358* Compute the condition number for comparison with
359* the value returned by ZGESVX (FACT = 'N' reuses
360* the condition number from the previous iteration
361* with FACT = 'F').
362*
363 CALL ZLACPY( 'full', N, N, ASAV, LDA, AFAC, LDA )
364.OR..GT. IF( EQUIL IEQUED1 ) THEN
365*
366* Compute row and column scale factors to
367* equilibrate the matrix A.
368*
369 CALL ZGEEQU( N, N, AFAC, LDA, S, S( N+1 ),
370 $ ROWCND, COLCND, AMAX, INFO )
371.EQ..AND..GT. IF( INFO0 N0 ) THEN
372 IF( LSAME( EQUED, 'r' ) ) THEN
373 ROWCND = ZERO
374 COLCND = ONE
375 ELSE IF( LSAME( EQUED, 'c' ) ) THEN
376 ROWCND = ONE
377 COLCND = ZERO
378 ELSE IF( LSAME( EQUED, 'b' ) ) THEN
379 ROWCND = ZERO
380 COLCND = ZERO
381 END IF
382*
383* Equilibrate the matrix.
384*
385 CALL ZLAQGE( N, N, AFAC, LDA, S, S( N+1 ),
386 $ ROWCND, COLCND, AMAX, EQUED )
387 END IF
388 END IF
389*
390* Save the condition number of the non-equilibrated
391* system for use in ZGET04.
392*
393 IF( EQUIL ) THEN
394 ROLDO = RCONDO
395 ROLDI = RCONDI
396 END IF
397*
398* Compute the 1-norm and infinity-norm of A.
399*
400 ANORMO = ZLANGE( '1', N, N, AFAC, LDA, RWORK )
401 ANORMI = ZLANGE( 'i', N, N, AFAC, LDA, RWORK )
402*
403* Factor the matrix A.
404*
405 SRNAMT = 'zgetrf'
406 CALL ZGETRF( N, N, AFAC, LDA, IWORK, INFO )
407*
408* Form the inverse of A.
409*
410 CALL ZLACPY( 'full', N, N, AFAC, LDA, A, LDA )
411 LWORK = NMAX*MAX( 3, NRHS )
412 SRNAMT = 'zgetri'
413 CALL ZGETRI( N, A, LDA, IWORK, WORK, LWORK, INFO )
414*
415* Compute the 1-norm condition number of A.
416*
417 AINVNM = ZLANGE( '1', N, N, A, LDA, RWORK )
418.LE..OR..LE. IF( ANORMOZERO AINVNMZERO ) THEN
419 RCONDO = ONE
420 ELSE
421 RCONDO = ( ONE / ANORMO ) / AINVNM
422 END IF
423*
424* Compute the infinity-norm condition number of A.
425*
426 AINVNM = ZLANGE( 'i', N, N, A, LDA, RWORK )
427.LE..OR..LE. IF( ANORMIZERO AINVNMZERO ) THEN
428 RCONDI = ONE
429 ELSE
430 RCONDI = ( ONE / ANORMI ) / AINVNM
431 END IF
432 END IF
433*
434 DO 50 ITRAN = 1, NTRAN
435*
436* Do for each value of TRANS.
437*
438 TRANS = TRANSS( ITRAN )
439.EQ. IF( ITRAN1 ) THEN
440 RCONDC = RCONDO
441 ELSE
442 RCONDC = RCONDI
443 END IF
444*
445* Restore the matrix A.
446*
447 CALL ZLACPY( 'full', N, N, ASAV, LDA, A, LDA )
448*
449* Form an exact solution and set the right hand side.
450*
451 SRNAMT = 'zlarhs'
452 CALL ZLARHS( PATH, XTYPE, 'full', TRANS, N, N, KL,
453 $ KU, NRHS, A, LDA, XACT, LDA, B, LDA,
454 $ ISEED, INFO )
455 XTYPE = 'c'
456 CALL ZLACPY( 'full', N, NRHS, B, LDA, BSAV, LDA )
457*
458.AND..EQ. IF( NOFACT ITRAN1 ) THEN
459*
460* --- Test ZGESV ---
461*
462* Compute the LU factorization of the matrix and
463* solve the system.
464*
465 CALL ZLACPY( 'full', N, N, A, LDA, AFAC, LDA )
466 CALL ZLACPY( 'full', N, NRHS, B, LDA, X, LDA )
467*
468 SRNAMT = 'zgesv '
469 CALL ZGESV( N, NRHS, AFAC, LDA, IWORK, X, LDA,
470 $ INFO )
471*
472* Check error code from ZGESV .
473*
474.NE. IF( INFOIZERO )
475 $ CALL ALAERH( PATH, 'zgesv ', INFO, IZERO,
476 $ ' ', N, N, -1, -1, NRHS, IMAT,
477 $ NFAIL, NERRS, NOUT )
478*
479* Reconstruct matrix from factors and compute
480* residual.
481*
482 CALL ZGET01( N, N, A, LDA, AFAC, LDA, IWORK,
483 $ RWORK, RESULT( 1 ) )
484 NT = 1
485.EQ. IF( IZERO0 ) THEN
486*
487* Compute residual of the computed solution.
488*
489 CALL ZLACPY( 'full', N, NRHS, B, LDA, WORK,
490 $ LDA )
491 CALL ZGET02( 'no transpose', N, N, NRHS, A,
492 $ LDA, X, LDA, WORK, LDA, RWORK,
493 $ RESULT( 2 ) )
494*
495* Check solution from generated exact solution.
496*
497 CALL ZGET04( N, NRHS, X, LDA, XACT, LDA,
498 $ RCONDC, RESULT( 3 ) )
499 NT = 3
500 END IF
501*
502* Print information about the tests that did not
503* pass the threshold.
504*
505 DO 30 K = 1, NT
506.GE. IF( RESULT( K )THRESH ) THEN
507.EQ..AND..EQ. IF( NFAIL0 NERRS0 )
508 $ CALL ALADHD( NOUT, PATH )
509 WRITE( NOUT, FMT = 9999 )'zgesv ', N,
510 $ IMAT, K, RESULT( K )
511 NFAIL = NFAIL + 1
512 END IF
513 30 CONTINUE
514 NRUN = NRUN + NT
515 END IF
516*
517* --- Test ZGESVX ---
518*
519.NOT. IF( PREFAC )
520 $ CALL ZLASET( 'full', N, N, DCMPLX( ZERO ),
521 $ DCMPLX( ZERO ), AFAC, LDA )
522 CALL ZLASET( 'full', N, NRHS, DCMPLX( ZERO ),
523 $ DCMPLX( ZERO ), X, LDA )
524.GT..AND..GT. IF( IEQUED1 N0 ) THEN
525*
526* Equilibrate the matrix if FACT = 'F' and
527* EQUED = 'R', 'C', or 'B'.
528*
529 CALL ZLAQGE( N, N, A, LDA, S, S( N+1 ), ROWCND,
530 $ COLCND, AMAX, EQUED )
531 END IF
532*
533* Solve the system and compute the condition number
534* and error bounds using ZGESVX.
535*
536 SRNAMT = 'zgesvx'
537 CALL ZGESVX( FACT, TRANS, N, NRHS, A, LDA, AFAC,
538 $ LDA, IWORK, EQUED, S, S( N+1 ), B,
539 $ LDA, X, LDA, RCOND, RWORK,
540 $ RWORK( NRHS+1 ), WORK,
541 $ RWORK( 2*NRHS+1 ), INFO )
542*
543* Check the error code from ZGESVX.
544*
545.NE. IF( INFOIZERO )
546 $ CALL ALAERH( PATH, 'zgesvx', INFO, IZERO,
547 $ FACT // TRANS, N, N, -1, -1, NRHS,
548 $ IMAT, NFAIL, NERRS, NOUT )
549*
550* Compare RWORK(2*NRHS+1) from ZGESVX with the
551* computed reciprocal pivot growth factor RPVGRW
552*
553.NE..AND..LE. IF( INFO0 INFON) THEN
554 RPVGRW = ZLANTR( 'm', 'u', 'n', INFO, INFO,
555 $ AFAC, LDA, RDUM )
556.EQ. IF( RPVGRWZERO ) THEN
557 RPVGRW = ONE
558 ELSE
559 RPVGRW = ZLANGE( 'm', N, INFO, A, LDA,
560 $ RDUM ) / RPVGRW
561 END IF
562 ELSE
563 RPVGRW = ZLANTR( 'm', 'u', 'n', N, N, AFAC, LDA,
564 $ RDUM )
565.EQ. IF( RPVGRWZERO ) THEN
566 RPVGRW = ONE
567 ELSE
568 RPVGRW = ZLANGE( 'm', N, N, A, LDA, RDUM ) /
569 $ RPVGRW
570 END IF
571 END IF
572 RESULT( 7 ) = ABS( RPVGRW-RWORK( 2*NRHS+1 ) ) /
573 $ MAX( RWORK( 2*NRHS+1 ), RPVGRW ) /
574 $ DLAMCH( 'e' )
575*
576.NOT. IF( PREFAC ) THEN
577*
578* Reconstruct matrix from factors and compute
579* residual.
580*
581 CALL ZGET01( N, N, A, LDA, AFAC, LDA, IWORK,
582 $ RWORK( 2*NRHS+1 ), RESULT( 1 ) )
583 K1 = 1
584 ELSE
585 K1 = 2
586 END IF
587*
588.EQ. IF( INFO0 ) THEN
589 TRFCON = .FALSE.
590*
591* Compute residual of the computed solution.
592*
593 CALL ZLACPY( 'full', N, NRHS, BSAV, LDA, WORK,
594 $ LDA )
595 CALL ZGET02( TRANS, N, N, NRHS, ASAV, LDA, X,
596 $ LDA, WORK, LDA, RWORK( 2*NRHS+1 ),
597 $ RESULT( 2 ) )
598*
599* Check solution from generated exact solution.
600*
601.OR..AND. IF( NOFACT ( PREFAC LSAME( EQUED,
602 $ 'n' ) ) ) THEN
603 CALL ZGET04( N, NRHS, X, LDA, XACT, LDA,
604 $ RCONDC, RESULT( 3 ) )
605 ELSE
606.EQ. IF( ITRAN1 ) THEN
607 ROLDC = ROLDO
608 ELSE
609 ROLDC = ROLDI
610 END IF
611 CALL ZGET04( N, NRHS, X, LDA, XACT, LDA,
612 $ ROLDC, RESULT( 3 ) )
613 END IF
614*
615* Check the error bounds from iterative
616* refinement.
617*
618 CALL ZGET07( TRANS, N, NRHS, ASAV, LDA, B, LDA,
619 $ X, LDA, XACT, LDA, RWORK, .TRUE.,
620 $ RWORK( NRHS+1 ), RESULT( 4 ) )
621 ELSE
622 TRFCON = .TRUE.
623 END IF
624*
625* Compare RCOND from ZGESVX with the computed value
626* in RCONDC.
627*
628 RESULT( 6 ) = DGET06( RCOND, RCONDC )
629*
630* Print information about the tests that did not pass
631* the threshold.
632*
633.NOT. IF( TRFCON ) THEN
634 DO 40 K = K1, NTESTS
635.GE. IF( RESULT( K )THRESH ) THEN
636.EQ..AND..EQ. IF( NFAIL0 NERRS0 )
637 $ CALL ALADHD( NOUT, PATH )
638 IF( PREFAC ) THEN
639 WRITE( NOUT, FMT = 9997 )'zgesvx',
640 $ FACT, TRANS, N, EQUED, IMAT, K,
641 $ RESULT( K )
642 ELSE
643 WRITE( NOUT, FMT = 9998 )'zgesvx',
644 $ FACT, TRANS, N, IMAT, K, RESULT( K )
645 END IF
646 NFAIL = NFAIL + 1
647 END IF
648 40 CONTINUE
649 NRUN = NRUN + NTESTS - K1 + 1
650 ELSE
651.GE..AND..NOT. IF( RESULT( 1 )THRESH PREFAC )
652 $ THEN
653.EQ..AND..EQ. IF( NFAIL0 NERRS0 )
654 $ CALL ALADHD( NOUT, PATH )
655 IF( PREFAC ) THEN
656 WRITE( NOUT, FMT = 9997 )'zgesvx', FACT,
657 $ TRANS, N, EQUED, IMAT, 1, RESULT( 1 )
658 ELSE
659 WRITE( NOUT, FMT = 9998 )'zgesvx', FACT,
660 $ TRANS, N, IMAT, 1, RESULT( 1 )
661 END IF
662 NFAIL = NFAIL + 1
663 NRUN = NRUN + 1
664 END IF
665.GE. IF( RESULT( 6 )THRESH ) THEN
666.EQ..AND..EQ. IF( NFAIL0 NERRS0 )
667 $ CALL ALADHD( NOUT, PATH )
668 IF( PREFAC ) THEN
669 WRITE( NOUT, FMT = 9997 )'zgesvx', FACT,
670 $ TRANS, N, EQUED, IMAT, 6, RESULT( 6 )
671 ELSE
672 WRITE( NOUT, FMT = 9998 )'zgesvx', FACT,
673 $ TRANS, N, IMAT, 6, RESULT( 6 )
674 END IF
675 NFAIL = NFAIL + 1
676 NRUN = NRUN + 1
677 END IF
678.GE. IF( RESULT( 7 )THRESH ) THEN
679.EQ..AND..EQ. IF( NFAIL0 NERRS0 )
680 $ CALL ALADHD( NOUT, PATH )
681 IF( PREFAC ) THEN
682 WRITE( NOUT, FMT = 9997 )'zgesvx', FACT,
683 $ TRANS, N, EQUED, IMAT, 7, RESULT( 7 )
684 ELSE
685 WRITE( NOUT, FMT = 9998 )'zgesvx', FACT,
686 $ TRANS, N, IMAT, 7, RESULT( 7 )
687 END IF
688 NFAIL = NFAIL + 1
689 NRUN = NRUN + 1
690 END IF
691*
692 END IF
693*
694 50 CONTINUE
695 60 CONTINUE
696 70 CONTINUE
697 80 CONTINUE
698 90 CONTINUE
699*
700* Print a summary of the results.
701*
702 CALL ALASVM( PATH, NOUT, NFAIL, NRUN, NERRS )
703*
704 9999 FORMAT( 1X, A, ', n =', i5, ', type ', i2, ', test(', i2, ') =',
705 $ g12.5 )
706 9998 FORMAT( 1x, a, ', FACT=''', a1, ''', trans=''', A1, ''', n=', I5,
707 $ ', type ', I2, ', test(', I1, ')=', G12.5 )
708 9997 FORMAT( 1X, A, ', fact=''', A1, ''', trans=''', A1, ''', n=', I5,
709 $ ', equed=''', A1, ''', type ', I2, ', test(', I1, ')=',
710 $ G12.5 )
711 RETURN
712*
713* End of ZDRVGE
714*
715 END
xlaenv
subroutine xlaenv(ispec, nvalue)
XLAENV
Definition xlaenv.f:81
alasvm
subroutine alasvm(type, nout, nfail, nrun, nerrs)
ALASVM
Definition alasvm.f:73
aladhd
subroutine aladhd(iounit, path)
ALADHD
Definition aladhd.f:90
alaerh
subroutine alaerh(path, subnam, info, infoe, opts, m, n, kl, ku, n5, imat, nfail, nerrs, nout)
ALAERH
Definition alaerh.f:147
zlaqge
subroutine zlaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed)
ZLAQGE scales a general rectangular matrix, using row and column scaling factors computed by sgeequ.
Definition zlaqge.f:143
zgetri
subroutine zgetri(n, a, lda, ipiv, work, lwork, info)
ZGETRI
Definition zgetri.f:114
zgeequ
subroutine zgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)
ZGEEQU
Definition zgeequ.f:140
zgesv
subroutine zgesv(n, nrhs, a, lda, ipiv, b, ldb, info)
ZGESV computes the solution to system of linear equations A * X = B for GE matrices (simple driver)
Definition zgesv.f:122
zgesvx
subroutine zgesvx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info)
ZGESVX computes the solution to system of linear equations A * X = B for GE matrices
Definition zgesvx.f:350
zlacpy
subroutine zlacpy(uplo, m, n, a, lda, b, ldb)
ZLACPY copies all or part of one two-dimensional array to another.
Definition zlacpy.f:103
zlaset
subroutine zlaset(uplo, m, n, alpha, beta, a, lda)
ZLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition zlaset.f:106
zlarhs
subroutine zlarhs(path, xtype, uplo, trans, m, n, kl, ku, nrhs, a, lda, x, ldx, b, ldb, iseed, info)
ZLARHS
Definition zlarhs.f:208
zget02
subroutine zget02(trans, m, n, nrhs, a, lda, x, ldx, b, ldb, rwork, resid)
ZGET02
Definition zget02.f:134
zget07
subroutine zget07(trans, n, nrhs, a, lda, b, ldb, x, ldx, xact, ldxact, ferr, chkferr, berr, reslts)
ZGET07
Definition zget07.f:166
zerrvx
subroutine zerrvx(path, nunit)
ZERRVX
Definition zerrvx.f:55
zget04
subroutine zget04(n, nrhs, x, ldx, xact, ldxact, rcond, resid)
ZGET04
Definition zget04.f:102
zget01
subroutine zget01(m, n, a, lda, afac, ldafac, ipiv, rwork, resid)
ZGET01
Definition zget01.f:108
zdrvge
subroutine zdrvge(dotype, nn, nval, nrhs, thresh, tsterr, nmax, a, afac, asav, b, bsav, x, xact, s, work, rwork, iwork, nout)
ZDRVGE
Definition zdrvge.f:164
zlatb4
subroutine zlatb4(path, imat, m, n, type, kl, ku, anorm, mode, cndnum, dist)
ZLATB4
Definition zlatb4.f:121
zlatms
subroutine zlatms(m, n, dist, iseed, sym, d, mode, cond, dmax, kl, ku, pack, a, lda, work, info)
ZLATMS
Definition zlatms.f:332
zgetrf
subroutine zgetrf(m, n, a, lda, ipiv, info)
ZGETRF VARIANT: Crout Level 3 BLAS version of the algorithm.
Definition zgetrf.f:102
max
#define max(a, b)
Definition macros.h:21