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