ScaLAPACK 2.1  2.1
ScaLAPACK: Scalable Linear Algebra PACKage
pzevcdriver.f
Go to the documentation of this file.
1  PROGRAM pzevcdriver
2 *
3 * -- ScaLAPACK testing driver (version 1.7) --
4 * University of Tennessee, Knoxville, Oak Ridge National Laboratory,
5 * and University of California, Berkeley.
6 * June, 2000
7 *
8 * Purpose
9 * =======
10 *
11 * PZEVCDRIVER is the main test program for the COMPLEX*16
12 * SCALAPACK PZTREVC routine. This test driver performs a right and
13 * left eigenvector calculation of a triangular matrix followed by
14 * a residual checks of the calcuated eigenvectors.
15 *
16 * The program must be driven by a short data file and uses the same
17 * input file as the PZNEPDRIVER. An annotated example of a data file
18 * can be obtained by deleting the first 3 characters from the following
19 * 18 lines:
20 * 'SCALAPACK, Version 1.8, NEP (Nonsymmetric EigenProblem) input file'
21 * 'Intel iPSC/860 hypercube, gamma model.'
22 * 'NEP.out' output file name (if any)
23 * 6 device out
24 * 8 number of problems sizes
25 * 1 2 3 4 6 10 100 200 vales of N
26 * 3 number of NB's
27 * 6 20 40 values of NB
28 * 4 number of process grids (ordered pairs of P & Q)
29 * 1 2 1 4 values of P
30 * 1 2 4 1 values of Q
31 * 20.0 threshold
32 *
33 * Internal Parameters
34 * ===================
35 *
36 * TOTMEM INTEGER, default = 2000000
37 * TOTMEM is a machine-specific parameter indicating the
38 * maximum amount of available memory in bytes.
39 * The user should customize TOTMEM to his platform. Remember
40 * to leave room in memory for the operating system, the BLACS
41 * buffer, etc. For example, on a system with 8 MB of memory
42 * per process (e.g., one processor on an Intel iPSC/860), the
43 * parameters we use are TOTMEM=6200000 (leaving 1.8 MB for OS,
44 * code, BLACS buffer, etc). However, for PVM, we usually set
45 * TOTMEM = 2000000. Some experimenting with the maximum value
46 * of TOTMEM may be required.
47 *
48 * ZPLXSZ INTEGER, default = 16 bytes.
49 * ZPLXSZ indicate the length in bytes on the given platform
50 * for a double precision complex.
51 * MEM COMPLEX*16 array, dimension ( TOTMEM / ZPLXSZ )
52 *
53 * All arrays used by SCALAPACK routines are allocated from
54 * this array and referenced by pointers. The integer IPA,
55 * for example, is a pointer to the starting element of MEM for
56 * the matrix A.
57 *
58 * Further Details
59 * ==============
60 *
61 * Contributed by Mark Fahey, June, 2000
62 *
63 * =====================================================================
64 *
65 * .. Parameters ..
66  INTEGER block_cyclic_2d, csrc_, ctxt_, dlen_, dt_,
67  $ lld_, mb_, m_, nb_, n_, rsrc_
68  parameter( block_cyclic_2d = 1, dlen_ = 9, dt_ = 1,
69  $ ctxt_ = 2, m_ = 3, n_ = 4, mb_ = 5, nb_ = 6,
70  $ rsrc_ = 7, csrc_ = 8, lld_ = 9 )
71  INTEGER zplxsz, totmem, memsiz, ntests
72  parameter( zplxsz = 16, totmem = 200000000,
73  $ memsiz = totmem / zplxsz, ntests = 20 )
74  COMPLEX*16 padval, zero, one
75  parameter( padval = ( -9923.0d+0, -9923.0d+0 ),
76  $ zero = ( 0.0d+0, 0.0d+0 ),
77  $ one = ( 1.0d+0, 0.0d+0 ) )
78 * ..
79 * .. Local Scalars ..
80  LOGICAL check
81  CHARACTER*6 passed
82  CHARACTER*80 outfile
83  INTEGER i, iam, iaseed, icol, ictxt, ii, iii, imidpad,
84  $ info, ipa, ipostpad, iprepad, ipvl, ipvr, ipw,
85  $ ipwr, ipz, irow, j, jj, jjj, k, kfail, kpass,
86  $ kskip, ktests, lda, ldz, lwork, m, mycol,
87  $ myrow, n, nb, ngrids, nmat, nnb, nout, np,
88  $ npcol, nprocs, nprow, nq, worksiz
89  REAL thresh
90  DOUBLE PRECISION anorm, fresid, nops, qresid, tmflops
91 * ..
92 * .. Local Arrays ..
93  LOGICAL select( 1 )
94  INTEGER desca( dlen_ ), descz( dlen_ ), ierr( 2 ),
95  $ nbval( ntests ), nval( ntests ),
96  $ pval( ntests ), qval( ntests )
97  DOUBLE PRECISION ctime( 2 ), result( 2 ), rwork( 5000 ),
98  $ wtime( 2 )
99  COMPLEX*16 mem( memsiz )
100 * ..
101 * .. External Subroutines ..
102  EXTERNAL blacs_barrier, blacs_exit, blacs_get,
103  $ blacs_gridexit, blacs_gridinfo, blacs_gridinit,
104  $ blacs_pinfo, descinit, igsum2d, infog2l,
105  $ pzchekpad, pzevcinfo, pzfillpad, pzget22,
106  $ pzlaset, pzmatgen, pztrevc, slboot, slcombine,
107  $ sltimer, zgsum2d
108 * ..
109 * .. External Functions ..
110  INTEGER ilcm, numroc
111  DOUBLE PRECISION pzlanhs
112  EXTERNAL ilcm, numroc, pzlanhs
113 * ..
114 * .. Intrinsic Functions ..
115  INTRINSIC dble, max, min
116 * ..
117 * .. Data statements ..
118  DATA kfail, kpass, kskip, ktests / 4*0 /
119 * ..
120 * .. Executable Statements ..
121 *
122 * Get starting information
123 *
124  CALL blacs_pinfo( iam, nprocs )
125  iaseed = 100
126  CALL pzevcinfo( outfile, nout, nmat, nval, ntests, nnb, nbval,
127  $ ntests, ngrids, pval, ntests, qval, ntests,
128  $ thresh, mem, iam, nprocs )
129  check = ( thresh.GE.0.0e+0 )
130 *
131 * Print headings
132 *
133  IF( iam.EQ.0 ) THEN
134  WRITE( nout, fmt = * )
135  WRITE( nout, fmt = 9995 )
136  WRITE( nout, fmt = 9994 )
137  WRITE( nout, fmt = * )
138  END IF
139 *
140 * Loop over different process grids
141 *
142  DO 40 i = 1, ngrids
143 *
144  nprow = pval( i )
145  npcol = qval( i )
146 *
147 * Make sure grid information is correct
148 *
149  ierr( 1 ) = 0
150  IF( nprow.LT.1 ) THEN
151  IF( iam.EQ.0 )
152  $ WRITE( nout, fmt = 9999 )'GRID', 'nprow', nprow
153  ierr( 1 ) = 1
154  ELSE IF( npcol.LT.1 ) THEN
155  IF( iam.EQ.0 )
156  $ WRITE( nout, fmt = 9999 )'GRID', 'npcol', npcol
157  ierr( 1 ) = 1
158  ELSE IF( nprow*npcol.GT.nprocs ) THEN
159  IF( iam.EQ.0 )
160  $ WRITE( nout, fmt = 9998 )nprow*npcol, nprocs
161  ierr( 1 ) = 1
162  END IF
163 *
164  IF( ierr( 1 ).GT.0 ) THEN
165  IF( iam.EQ.0 )
166  $ WRITE( nout, fmt = 9997 )'grid'
167  kskip = kskip + 1
168  GO TO 40
169  END IF
170 *
171 * Define process grid
172 *
173  CALL blacs_get( -1, 0, ictxt )
174  CALL blacs_gridinit( ictxt, 'Row-major', nprow, npcol )
175  CALL blacs_gridinfo( ictxt, nprow, npcol, myrow, mycol )
176 *
177 * Go to bottom of process grid loop if this case doesn't use my
178 * process
179 *
180  IF( myrow.GE.nprow .OR. mycol.GE.npcol )
181  $ GO TO 40
182 *
183  DO 30 j = 1, nmat
184 *
185  n = nval( j )
186 *
187 * Make sure matrix information is correct
188 *
189  ierr( 1 ) = 0
190  IF( n.LT.1 ) THEN
191  IF( iam.EQ.0 )
192  $ WRITE( nout, fmt = 9999 )'MATRIX', 'N', n
193  ierr( 1 ) = 1
194  END IF
195 *
196 * Check all processes for an error
197 *
198  CALL igsum2d( ictxt, 'All', ' ', 1, 1, ierr, 1, -1, 0 )
199 *
200  IF( ierr( 1 ).GT.0 ) THEN
201  IF( iam.EQ.0 )
202  $ WRITE( nout, fmt = 9997 )'matrix'
203  kskip = kskip + 1
204  GO TO 30
205  END IF
206 *
207  DO 20 k = 1, nnb
208 *
209  nb = nbval( k )
210 *
211 * Make sure nb is legal
212 *
213  ierr( 1 ) = 0
214  IF( nb.LT.6 ) THEN
215  ierr( 1 ) = 1
216  IF( iam.EQ.0 )
217  $ WRITE( nout, fmt = 9999 )'NB', 'NB', nb
218  END IF
219 *
220 * Check all processes for an error
221 *
222  CALL igsum2d( ictxt, 'All', ' ', 1, 1, ierr, 1, -1, 0 )
223 *
224  IF( ierr( 1 ).GT.0 ) THEN
225  IF( iam.EQ.0 )
226  $ WRITE( nout, fmt = 9997 )'NB'
227  kskip = kskip + 1
228  GO TO 20
229  END IF
230 *
231 * Padding constants
232 *
233  np = numroc( n, nb, myrow, 0, nprow )
234  nq = numroc( n, nb, mycol, 0, npcol )
235  IF( check ) THEN
236  iprepad = max( nb, np )
237  imidpad = nb
238  ipostpad = max( nb, nq )
239  iprepad = iprepad + 1000
240  imidpad = imidpad + 1000
241  ipostpad = ipostpad + 1000
242  ELSE
243  iprepad = 0
244  imidpad = 0
245  ipostpad = 0
246  END IF
247 *
248 * Initialize the array descriptor for the matrix A
249 *
250  CALL descinit( desca, n, n, nb, nb, 0, 0, ictxt,
251  $ max( 1, np )+imidpad, ierr( 1 ) )
252 *
253 * Initialize the array descriptor for the matrix Z
254 *
255  CALL descinit( descz, n, n, nb, nb, 0, 0, ictxt,
256  $ max( 1, np )+imidpad, ierr( 2 ) )
257 *
258  lda = desca( lld_ )
259  ldz = descz( lld_ )
260 *
261 * Check all processes for an error
262 *
263  CALL igsum2d( ictxt, 'All', ' ', 2, 1, ierr, 2, -1, 0 )
264 *
265  IF( ierr( 1 ).LT.0 .OR. ierr( 2 ).LT.0 ) THEN
266  IF( iam.EQ.0 )
267  $ WRITE( nout, fmt = 9997 )'descriptor'
268  kskip = kskip + 1
269  GO TO 20
270  END IF
271 *
272 * Assign pointers into MEM for SCALAPACK arrays, A is
273 * allocated starting at position MEM( IPREPAD+1 )
274 *
275  ipa = iprepad + 1
276  ipz = ipa + desca( lld_ )*nq + ipostpad + iprepad
277  ipwr = ipz + descz( lld_ )*nq + ipostpad + iprepad
278  ipvl = ipwr + n + ipostpad + iprepad
279  ipvr = ipvl + descz( lld_ )*nq + ipostpad + iprepad
280  ipw = ipvr + descz( lld_ )*nq + ipostpad + iprepad
281  iii = n / nb
282  IF( iii*nb.LT.n )
283  $ iii = iii + 1
284  iii = 7*iii / ilcm( nprow, npcol )
285 *
286 *
287  lwork = 3*n + max( 2*max( lda, ldz )+2*nq, iii )
288  lwork = lwork + max( 2*n, ( 8*ilcm( nprow, npcol )+2 )**
289  $ 2 )
290 *
291  IF( check ) THEN
292 *
293 * Figure the amount of workspace required by the
294 * checking routines PZEVCFCHK and PZLANHS
295 *
296  worksiz = lwork + max( np*desca( nb_ ),
297  $ desca( mb_ )*nq ) + ipostpad
298 *
299  ELSE
300 *
301  worksiz = lwork + ipostpad
302 *
303  END IF
304 *
305 * Check for adequate memory for problem size
306 *
307  ierr( 1 ) = 0
308  IF( ipw+worksiz.GT.memsiz ) THEN
309  IF( iam.EQ.0 )
310  $ WRITE( nout, fmt = 9996 )'Schur reduction',
311  $ ( ipw+worksiz )*zplxsz
312  ierr( 1 ) = 1
313  END IF
314 *
315 * Check all processes for an error
316 *
317  CALL igsum2d( ictxt, 'All', ' ', 1, 1, ierr, 1, -1, 0 )
318 *
319  IF( ierr( 1 ).GT.0 ) THEN
320  IF( iam.EQ.0 )
321  $ WRITE( nout, fmt = 9997 )'MEMORY'
322  kskip = kskip + 1
323  GO TO 20
324  END IF
325 *
326 * Generate matrix Z = In
327 *
328  CALL pzlaset( 'All', n, n, zero, one, mem( ipz ), 1, 1,
329  $ descz )
330  CALL pzlaset( 'All', n, n, zero, zero, mem( ipvr ), 1, 1,
331  $ descz )
332  CALL pzlaset( 'All', n, n, zero, zero, mem( ipvl ), 1, 1,
333  $ descz )
334 *
335 * Generate matrix A upper Hessenberg
336 *
337  CALL pzmatgen( ictxt, 'No transpose', 'No transpose',
338  $ desca( m_ ), desca( n_ ), desca( mb_ ),
339  $ desca( nb_ ), mem( ipa ), desca( lld_ ),
340  $ desca( rsrc_ ), desca( csrc_ ), iaseed, 0,
341  $ np, 0, nq, myrow, mycol, nprow, npcol )
342  CALL pzlaset( 'Lower', max( 0, n-1 ), max( 0, n-1 ),
343  $ zero, zero, mem( ipa ), min( n, 2 ), 1,
344  $ desca )
345 *
346 * Calculate inf-norm of A for residual error-checking
347 *
348  IF( check ) THEN
349  CALL pzfillpad( ictxt, np, nq, mem( ipa-iprepad ),
350  $ desca( lld_ ), iprepad, ipostpad,
351  $ padval )
352  CALL pzfillpad( ictxt, np, nq, mem( ipvr-iprepad ),
353  $ descz( lld_ ), iprepad, ipostpad,
354  $ padval )
355  CALL pzfillpad( ictxt, np, nq, mem( ipvl-iprepad ),
356  $ descz( lld_ ), iprepad, ipostpad,
357  $ padval )
358  CALL pzfillpad( ictxt, np, nq, mem( ipz-iprepad ),
359  $ descz( lld_ ), iprepad, ipostpad,
360  $ padval )
361  CALL pzfillpad( ictxt, worksiz-ipostpad, 1,
362  $ mem( ipw-iprepad ), worksiz-ipostpad,
363  $ iprepad, ipostpad, padval )
364  anorm = pzlanhs( 'I', n, mem( ipa ), 1, 1, desca,
365  $ mem( ipw ) )
366  CALL pzchekpad( ictxt, 'PZLANHS', np, nq,
367  $ mem( ipa-iprepad ), desca( lld_ ),
368  $ iprepad, ipostpad, padval )
369  CALL pzchekpad( ictxt, 'PZLANHS', worksiz-ipostpad, 1,
370  $ mem( ipw-iprepad ), worksiz-ipostpad,
371  $ iprepad, ipostpad, padval )
372 *
373  CALL pzfillpad( ictxt, n, 1, mem( ipwr-iprepad ), n,
374  $ iprepad, ipostpad, padval )
375  CALL pzfillpad( ictxt, lwork, 1, mem( ipw-iprepad ),
376  $ lwork, iprepad, ipostpad, padval )
377 *
378  END IF
379 *
380 * Set eigenvalues from diagonal
381 *
382  DO 10 jjj = 1, n
383  CALL infog2l( jjj, jjj, descz, nprow, npcol, myrow,
384  $ mycol, irow, icol, ii, jj )
385  IF( myrow.EQ.ii .AND. mycol.EQ.jj ) THEN
386  mem( ipwr-1+jjj ) = mem( ipa-1+( icol-1 )*lda+
387  $ irow )
388  ELSE
389  mem( ipwr-1+jjj ) = zero
390  END IF
391  10 CONTINUE
392  CALL zgsum2d( ictxt, 'All', ' ', n, 1, mem( ipwr ), n,
393  $ -1, -1 )
394 *
395  SELECT( 1 ) = .true.
396  CALL slboot
397  CALL blacs_barrier( ictxt, 'All' )
398  CALL sltimer( 1 )
399 *
400 * Perform eigenvector calculation
401 *
402  CALL pztrevc( 'B', 'A', SELECT, n, mem( ipa ), desca,
403  $ mem( ipvl ), descz, mem( ipvr ), descz, n,
404  $ m, mem( ipw ), rwork, info )
405 *
406  CALL sltimer( 1 )
407 *
408  IF( info.NE.0 ) THEN
409  IF( iam.EQ.0 )
410  $ WRITE( nout, fmt = * )'PZTREVC INFO=', info
411  kfail = kfail + 1
412  GO TO 20
413  END IF
414 *
415  IF( check ) THEN
416 *
417 * Check for memory overwrite in NEP factorization
418 *
419  CALL pzchekpad( ictxt, 'PZTREVC (A)', np, nq,
420  $ mem( ipa-iprepad ), desca( lld_ ),
421  $ iprepad, ipostpad, padval )
422  CALL pzchekpad( ictxt, 'PZTREVC (VR)', np, nq,
423  $ mem( ipvr-iprepad ), descz( lld_ ),
424  $ iprepad, ipostpad, padval )
425  CALL pzchekpad( ictxt, 'PZTREVC (VL)', np, nq,
426  $ mem( ipvl-iprepad ), descz( lld_ ),
427  $ iprepad, ipostpad, padval )
428  CALL pzchekpad( ictxt, 'PZTREVC (WR)', n, 1,
429  $ mem( ipwr-iprepad ), n, iprepad,
430  $ ipostpad, padval )
431  CALL pzchekpad( ictxt, 'PZTREVC (WORK)', lwork, 1,
432  $ mem( ipw-iprepad ), lwork, iprepad,
433  $ ipostpad, padval )
434 *
435  CALL pzfillpad( ictxt, worksiz-ipostpad, 1,
436  $ mem( ipw-iprepad ), worksiz-ipostpad,
437  $ iprepad, ipostpad, padval )
438 *
439 * Compute || T * Z - Z * D || / ( N*|| T ||*EPS )
440 *
441  fresid = 0.0d+0
442  qresid = 0.0d+0
443  CALL pzget22( 'N', 'N', 'N', n, mem( ipa ), desca,
444  $ mem( ipvr ), descz, mem( ipwr ),
445  $ mem( ipz ), descz, rwork, result )
446  fresid = result( 1 )
447  qresid = result( 2 )
448 *
449 * Compute || T^H * L - L * D^H || / ( N*|| T ||*EPS )
450 *
451  CALL pzget22( 'C', 'N', 'C', n, mem( ipa ), desca,
452  $ mem( ipvl ), descz, mem( ipwr ),
453  $ mem( ipz ), descz, rwork, result )
454  fresid = max( fresid, result( 1 ) )
455  qresid = max( qresid, result( 2 ) )
456 *
457  CALL pzchekpad( ictxt, 'PZGET22 (A)', np, nq,
458  $ mem( ipa-iprepad ), desca( lld_ ),
459  $ iprepad, ipostpad, padval )
460  CALL pzchekpad( ictxt, 'PZGET22 (VR)', np, nq,
461  $ mem( ipvr-iprepad ), descz( lld_ ),
462  $ iprepad, ipostpad, padval )
463  CALL pzchekpad( ictxt, 'PZGET22 (VL)', np, nq,
464  $ mem( ipvl-iprepad ), descz( lld_ ),
465  $ iprepad, ipostpad, padval )
466  CALL pzchekpad( ictxt, 'PZGET22 (Z)', np, nq,
467  $ mem( ipz-iprepad ), descz( lld_ ),
468  $ iprepad, ipostpad, padval )
469 *
470 * Test residual and detect NaN result
471 *
472  IF( ( fresid.LE.thresh ) .AND.
473  $ ( ( fresid-fresid ).EQ.0.0d+0 ) .AND.
474  $ ( qresid.LE.thresh ) .AND.
475  $ ( ( qresid-qresid ).EQ.0.0d+0 ) ) THEN
476  kpass = kpass + 1
477  passed = 'PASSED'
478  ELSE
479  kfail = kfail + 1
480  passed = 'FAILED'
481  IF( iam.EQ.0 ) THEN
482  WRITE( nout, fmt = 9986 )fresid
483  WRITE( nout, fmt = 9985 )qresid
484  END IF
485  END IF
486 *
487  ELSE
488 *
489 * Don't perform the checking, only timing
490 *
491  kpass = kpass + 1
492  fresid = fresid - fresid
493  qresid = qresid - qresid
494  passed = 'BYPASS'
495 *
496  END IF
497 *
498 * Gather maximum of all CPU and WALL clock timings
499 *
500  CALL slcombine( ictxt, 'All', '>', 'W', 1, 1, wtime )
501  CALL slcombine( ictxt, 'All', '>', 'C', 1, 1, ctime )
502 *
503 * Print results
504 *
505  IF( myrow.EQ.0 .AND. mycol.EQ.0 ) THEN
506 *
507 * 2 N^2 flops for PxTREVC
508 *
509  nops = 2.0d+0*dble( n )**2
510 *
511 * Calculate total megaflops -- eigenvector calc only,
512 * -- for WALL and CPU time, and print output
513 *
514 * Print WALL time if machine supports it
515 *
516  IF( wtime( 1 ).GT.0.0d+0 ) THEN
517  tmflops = nops / ( wtime( 1 )*1.0d+6 )
518  ELSE
519  tmflops = 0.0d+0
520  END IF
521  IF( wtime( 1 ).GE.0.0d+0 )
522  $ WRITE( nout, fmt = 9993 )'WALL', n, nb, nprow,
523  $ npcol, wtime( 1 ), tmflops, passed
524 *
525 * Print CPU time if machine supports it
526 *
527  IF( ctime( 1 ).GT.0.0d+0 ) THEN
528  tmflops = nops / ( ctime( 1 )*1.0d+6 )
529  ELSE
530  tmflops = 0.0d+0
531  END IF
532 *
533  IF( ctime( 1 ).GE.0.0d+0 )
534  $ WRITE( nout, fmt = 9993 )'CPU ', n, nb, nprow,
535  $ npcol, ctime( 1 ), tmflops, passed
536  END IF
537 *
538  20 CONTINUE
539 *
540  30 CONTINUE
541 *
542  CALL blacs_gridexit( ictxt )
543 *
544  40 CONTINUE
545 *
546 * Print ending messages and close output file
547 *
548  IF( iam.EQ.0 ) THEN
549  ktests = kpass + kfail + kskip
550  WRITE( nout, fmt = * )
551  WRITE( nout, fmt = 9992 )ktests
552  IF( check ) THEN
553  WRITE( nout, fmt = 9991 )kpass
554  WRITE( nout, fmt = 9989 )kfail
555  ELSE
556  WRITE( nout, fmt = 9990 )kpass
557  END IF
558  WRITE( nout, fmt = 9988 )kskip
559  WRITE( nout, fmt = * )
560  WRITE( nout, fmt = * )
561  WRITE( nout, fmt = 9987 )
562  IF( nout.NE.6 .AND. nout.NE.0 )
563  $ CLOSE ( nout )
564  END IF
565 *
566  CALL blacs_exit( 0 )
567 *
568  9999 FORMAT( 'ILLEGAL ', a6, ': ', a5, ' = ', i3,
569  $ '; It should be at least 1' )
570  9998 FORMAT( 'ILLEGAL GRID: nprow*npcol = ', i4, '. It can be at most',
571  $ i4 )
572  9997 FORMAT( 'Bad ', a6, ' parameters: going on to next test case.' )
573  9996 FORMAT( 'Unable to perform ', a, ': need TOTMEM of at least',
574  $ i11 )
575  9995 FORMAT( 'TIME N NB P Q NEP Time MFLOPS CHECK' )
576  9994 FORMAT( '---- ----- --- ---- ---- -------- -------- ------' )
577  9993 FORMAT( a4, 1x, i5, 1x, i3, 1x, i4, 1x, i4, 1x, f8.2, 1x, f8.2,
578  $ 1x, a6 )
579  9992 FORMAT( 'Finished ', i6, ' tests, with the following results:' )
580  9991 FORMAT( i5, ' tests completed and passed residual checks.' )
581  9990 FORMAT( i5, ' tests completed without checking.' )
582  9989 FORMAT( i5, ' tests completed and failed residual checks.' )
583  9988 FORMAT( i5, ' tests skipped because of illegal input values.' )
584  9987 FORMAT( 'END OF TESTS.' )
585  9986 FORMAT( '||H*Z - Z*D|| / (||T|| * N * eps) = ', g25.7 )
586  9985 FORMAT( 'max_j(max|Z(j)| - 1) / ( N * eps ) ', g25.7 )
587 *
588  stop
589 *
590 * End of PZEVCDRIVER
591 *
592  END
pzlanhs
double precision function pzlanhs(NORM, N, A, IA, JA, DESCA, WORK)
Definition: pzlanhs.f:3
pzget22
subroutine pzget22(TRANSA, TRANSE, TRANSW, N, A, DESCA, E, DESCE, W, WORK, DESCW, RWORK, RESULT)
Definition: pzget22.f:3
max
#define max(A, B)
Definition: pcgemr.c:180
ilcm
integer function ilcm(M, N)
Definition: ilcm.f:2
infog2l
subroutine infog2l(GRINDX, GCINDX, DESC, NPROW, NPCOL, MYROW, MYCOL, LRINDX, LCINDX, RSRC, CSRC)
Definition: infog2l.f:3
sltimer
subroutine sltimer(I)
Definition: sltimer.f:47
pztrevc
subroutine pztrevc(SIDE, HOWMNY, SELECT, N, T, DESCT, VL, DESCVL, VR, DESCVR, MM, M, WORK, RWORK, INFO)
Definition: pztrevc.f:3
pzevcinfo
subroutine pzevcinfo(SUMMRY, NOUT, NMAT, NVAL, LDNVAL, NNB, NBVAL, LDNBVAL, NGRIDS, PVAL, LDPVAL, QVAL, LDQVAL, THRESH, WORK, IAM, NPROCS)
Definition: pzevcinfo.f:4
pzlaset
subroutine pzlaset(UPLO, M, N, ALPHA, BETA, A, IA, JA, DESCA)
Definition: pzblastst.f:7509
pzmatgen
subroutine pzmatgen(ICTXT, AFORM, DIAG, M, N, MB, NB, A, LDA, IAROW, IACOL, ISEED, IROFF, IRNUM, ICOFF, ICNUM, MYROW, MYCOL, NPROW, NPCOL)
Definition: pzmatgen.f:4
descinit
subroutine descinit(DESC, M, N, MB, NB, IRSRC, ICSRC, ICTXT, LLD, INFO)
Definition: descinit.f:3
slboot
subroutine slboot()
Definition: sltimer.f:2
numroc
integer function numroc(N, NB, IPROC, ISRCPROC, NPROCS)
Definition: numroc.f:2
pzevcdriver
program pzevcdriver
Definition: pzevcdriver.f:1
pzchekpad
subroutine pzchekpad(ICTXT, MESS, M, N, A, LDA, IPRE, IPOST, CHKVAL)
Definition: pzchekpad.f:3
slcombine
subroutine slcombine(ICTXT, SCOPE, OP, TIMETYPE, N, IBEG, TIMES)
Definition: sltimer.f:267
min
#define min(A, B)
Definition: pcgemr.c:181
pzfillpad
subroutine pzfillpad(ICTXT, M, N, A, LDA, IPRE, IPOST, CHKVAL)
Definition: pzfillpad.f:2