LAPACK  3.6.1
LAPACK: Linear Algebra PACKage
zdrvrfp.f
Go to the documentation of this file.
1 *> \brief \b ZDRVRFP
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 ZDRVRFP( NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL,
12 * + THRESH, A, ASAV, AFAC, AINV, B,
13 * + BSAV, XACT, X, ARF, ARFINV,
14 * + Z_WORK_ZLATMS, Z_WORK_ZPOT02,
15 * + Z_WORK_ZPOT03, D_WORK_ZLATMS, D_WORK_ZLANHE,
16 * + D_WORK_ZPOT01, D_WORK_ZPOT02, D_WORK_ZPOT03 )
17 *
18 * .. Scalar Arguments ..
19 * INTEGER NN, NNS, NNT, NOUT
20 * DOUBLE PRECISION THRESH
21 * ..
22 * .. Array Arguments ..
23 * INTEGER NVAL( NN ), NSVAL( NNS ), NTVAL( NNT )
24 * COMPLEX*16 A( * )
25 * COMPLEX*16 AINV( * )
26 * COMPLEX*16 ASAV( * )
27 * COMPLEX*16 B( * )
28 * COMPLEX*16 BSAV( * )
29 * COMPLEX*16 AFAC( * )
30 * COMPLEX*16 ARF( * )
31 * COMPLEX*16 ARFINV( * )
32 * COMPLEX*16 XACT( * )
33 * COMPLEX*16 X( * )
34 * COMPLEX*16 Z_WORK_ZLATMS( * )
35 * COMPLEX*16 Z_WORK_ZPOT02( * )
36 * COMPLEX*16 Z_WORK_ZPOT03( * )
37 * DOUBLE PRECISION D_WORK_ZLATMS( * )
38 * DOUBLE PRECISION D_WORK_ZLANHE( * )
39 * DOUBLE PRECISION D_WORK_ZPOT01( * )
40 * DOUBLE PRECISION D_WORK_ZPOT02( * )
41 * DOUBLE PRECISION D_WORK_ZPOT03( * )
42 * ..
43 *
44 *
45 *> \par Purpose:
46 * =============
47 *>
48 *> \verbatim
49 *>
50 *> ZDRVRFP tests the LAPACK RFP routines:
51 *> ZPFTRF, ZPFTRS, and ZPFTRI.
52 *>
53 *> This testing routine follow the same tests as ZDRVPO (test for the full
54 *> format Symmetric Positive Definite solver).
55 *>
56 *> The tests are performed in Full Format, convertion back and forth from
57 *> full format to RFP format are performed using the routines ZTRTTF and
58 *> ZTFTTR.
59 *>
60 *> First, a specific matrix A of size N is created. There is nine types of
61 *> different matrixes possible.
62 *> 1. Diagonal 6. Random, CNDNUM = sqrt(0.1/EPS)
63 *> 2. Random, CNDNUM = 2 7. Random, CNDNUM = 0.1/EPS
64 *> *3. First row and column zero 8. Scaled near underflow
65 *> *4. Last row and column zero 9. Scaled near overflow
66 *> *5. Middle row and column zero
67 *> (* - tests error exits from ZPFTRF, no test ratios are computed)
68 *> A solution XACT of size N-by-NRHS is created and the associated right
69 *> hand side B as well. Then ZPFTRF is called to compute L (or U), the
70 *> Cholesky factor of A. Then L (or U) is used to solve the linear system
71 *> of equations AX = B. This gives X. Then L (or U) is used to compute the
72 *> inverse of A, AINV. The following four tests are then performed:
73 *> (1) norm( L*L' - A ) / ( N * norm(A) * EPS ) or
74 *> norm( U'*U - A ) / ( N * norm(A) * EPS ),
75 *> (2) norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
76 *> (3) norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
77 *> (4) ( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS ),
78 *> where EPS is the machine precision, RCOND the condition number of A, and
79 *> norm( . ) the 1-norm for (1,2,3) and the inf-norm for (4).
80 *> Errors occur when INFO parameter is not as expected. Failures occur when
81 *> a test ratios is greater than THRES.
82 *> \endverbatim
83 *
84 * Arguments:
85 * ==========
86 *
87 *> \param[in] NOUT
88 *> \verbatim
89 *> NOUT is INTEGER
90 *> The unit number for output.
91 *> \endverbatim
92 *>
93 *> \param[in] NN
94 *> \verbatim
95 *> NN is INTEGER
96 *> The number of values of N contained in the vector NVAL.
97 *> \endverbatim
98 *>
99 *> \param[in] NVAL
100 *> \verbatim
101 *> NVAL is INTEGER array, dimension (NN)
102 *> The values of the matrix dimension N.
103 *> \endverbatim
104 *>
105 *> \param[in] NNS
106 *> \verbatim
107 *> NNS is INTEGER
108 *> The number of values of NRHS contained in the vector NSVAL.
109 *> \endverbatim
110 *>
111 *> \param[in] NSVAL
112 *> \verbatim
113 *> NSVAL is INTEGER array, dimension (NNS)
114 *> The values of the number of right-hand sides NRHS.
115 *> \endverbatim
116 *>
117 *> \param[in] NNT
118 *> \verbatim
119 *> NNT is INTEGER
120 *> The number of values of MATRIX TYPE contained in the vector NTVAL.
121 *> \endverbatim
122 *>
123 *> \param[in] NTVAL
124 *> \verbatim
125 *> NTVAL is INTEGER array, dimension (NNT)
126 *> The values of matrix type (between 0 and 9 for PO/PP/PF matrices).
127 *> \endverbatim
128 *>
129 *> \param[in] THRESH
130 *> \verbatim
131 *> THRESH is DOUBLE PRECISION
132 *> The threshold value for the test ratios. A result is
133 *> included in the output file if RESULT >= THRESH. To have
134 *> every test ratio printed, use THRESH = 0.
135 *> \endverbatim
136 *>
137 *> \param[out] A
138 *> \verbatim
139 *> A is COMPLEX*16 array, dimension (NMAX*NMAX)
140 *> \endverbatim
141 *>
142 *> \param[out] ASAV
143 *> \verbatim
144 *> ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
145 *> \endverbatim
146 *>
147 *> \param[out] AFAC
148 *> \verbatim
149 *> AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
150 *> \endverbatim
151 *>
152 *> \param[out] AINV
153 *> \verbatim
154 *> AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
155 *> \endverbatim
156 *>
157 *> \param[out] B
158 *> \verbatim
159 *> B is COMPLEX*16 array, dimension (NMAX*MAXRHS)
160 *> \endverbatim
161 *>
162 *> \param[out] BSAV
163 *> \verbatim
164 *> BSAV is COMPLEX*16 array, dimension (NMAX*MAXRHS)
165 *> \endverbatim
166 *>
167 *> \param[out] XACT
168 *> \verbatim
169 *> XACT is COMPLEX*16 array, dimension (NMAX*MAXRHS)
170 *> \endverbatim
171 *>
172 *> \param[out] X
173 *> \verbatim
174 *> X is COMPLEX*16 array, dimension (NMAX*MAXRHS)
175 *> \endverbatim
176 *>
177 *> \param[out] ARF
178 *> \verbatim
179 *> ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2)
180 *> \endverbatim
181 *>
182 *> \param[out] ARFINV
183 *> \verbatim
184 *> ARFINV is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2)
185 *> \endverbatim
186 *>
187 *> \param[out] Z_WORK_ZLATMS
188 *> \verbatim
189 *> Z_WORK_ZLATMS is COMPLEX*16 array, dimension ( 3*NMAX )
190 *> \endverbatim
191 *>
192 *> \param[out] Z_WORK_ZPOT02
193 *> \verbatim
194 *> Z_WORK_ZPOT02 is COMPLEX*16 array, dimension ( NMAX*MAXRHS )
195 *> \endverbatim
196 *>
197 *> \param[out] Z_WORK_ZPOT03
198 *> \verbatim
199 *> Z_WORK_ZPOT03 is COMPLEX*16 array, dimension ( NMAX*NMAX )
200 *> \endverbatim
201 *>
202 *> \param[out] D_WORK_ZLATMS
203 *> \verbatim
204 *> D_WORK_ZLATMS is DOUBLE PRECISION array, dimension ( NMAX )
205 *> \endverbatim
206 *>
207 *> \param[out] D_WORK_ZLANHE
208 *> \verbatim
209 *> D_WORK_ZLANHE is DOUBLE PRECISION array, dimension ( NMAX )
210 *> \endverbatim
211 *>
212 *> \param[out] D_WORK_ZPOT01
213 *> \verbatim
214 *> D_WORK_ZPOT01 is DOUBLE PRECISION array, dimension ( NMAX )
215 *> \endverbatim
216 *>
217 *> \param[out] D_WORK_ZPOT02
218 *> \verbatim
219 *> D_WORK_ZPOT02 is DOUBLE PRECISION array, dimension ( NMAX )
220 *> \endverbatim
221 *>
222 *> \param[out] D_WORK_ZPOT03
223 *> \verbatim
224 *> D_WORK_ZPOT03 is DOUBLE PRECISION array, dimension ( NMAX )
225 *> \endverbatim
226 *
227 * Authors:
228 * ========
229 *
230 *> \author Univ. of Tennessee
231 *> \author Univ. of California Berkeley
232 *> \author Univ. of Colorado Denver
233 *> \author NAG Ltd.
234 *
235 *> \date November 2013
236 *
237 *> \ingroup complex16_lin
238 *
239 * =====================================================================
240  SUBROUTINE zdrvrfp( NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL,
241  + thresh, a, asav, afac, ainv, b,
242  + bsav, xact, x, arf, arfinv,
243  + z_work_zlatms, z_work_zpot02,
244  + z_work_zpot03, d_work_zlatms, d_work_zlanhe,
245  + d_work_zpot01, d_work_zpot02, d_work_zpot03 )
246 *
247 * -- LAPACK test routine (version 3.5.0) --
248 * -- LAPACK is a software package provided by Univ. of Tennessee, --
249 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
250 * November 2013
251 *
252 * .. Scalar Arguments ..
253  INTEGER NN, NNS, NNT, NOUT
254  DOUBLE PRECISION THRESH
255 * ..
256 * .. Array Arguments ..
257  INTEGER NVAL( nn ), NSVAL( nns ), NTVAL( nnt )
258  COMPLEX*16 A( * )
259  COMPLEX*16 AINV( * )
260  COMPLEX*16 ASAV( * )
261  COMPLEX*16 B( * )
262  COMPLEX*16 BSAV( * )
263  COMPLEX*16 AFAC( * )
264  COMPLEX*16 ARF( * )
265  COMPLEX*16 ARFINV( * )
266  COMPLEX*16 XACT( * )
267  COMPLEX*16 X( * )
268  COMPLEX*16 Z_WORK_ZLATMS( * )
269  COMPLEX*16 Z_WORK_ZPOT02( * )
270  COMPLEX*16 Z_WORK_ZPOT03( * )
271  DOUBLE PRECISION D_WORK_ZLATMS( * )
272  DOUBLE PRECISION D_WORK_ZLANHE( * )
273  DOUBLE PRECISION D_WORK_ZPOT01( * )
274  DOUBLE PRECISION D_WORK_ZPOT02( * )
275  DOUBLE PRECISION D_WORK_ZPOT03( * )
276 * ..
277 *
278 * =====================================================================
279 *
280 * .. Parameters ..
281  DOUBLE PRECISION ONE, ZERO
282  parameter ( one = 1.0d+0, zero = 0.0d+0 )
283  INTEGER NTESTS
284  parameter ( ntests = 4 )
285 * ..
286 * .. Local Scalars ..
287  LOGICAL ZEROT
288  INTEGER I, INFO, IUPLO, LDA, LDB, IMAT, NERRS, NFAIL,
289  + nrhs, nrun, izero, ioff, k, nt, n, iform, iin,
290  + iit, iis
291  CHARACTER DIST, CTYPE, UPLO, CFORM
292  INTEGER KL, KU, MODE
293  DOUBLE PRECISION ANORM, AINVNM, CNDNUM, RCONDC
294 * ..
295 * .. Local Arrays ..
296  CHARACTER UPLOS( 2 ), FORMS( 2 )
297  INTEGER ISEED( 4 ), ISEEDY( 4 )
298  DOUBLE PRECISION RESULT( ntests )
299 * ..
300 * .. External Functions ..
301  DOUBLE PRECISION ZLANHE
302  EXTERNAL zlanhe
303 * ..
304 * .. External Subroutines ..
305  EXTERNAL aladhd, alaerh, alasvm, zget04, ztfttr, zlacpy,
306  + zlaipd, zlarhs, zlatb4, zlatms, zpftri, zpftrf,
307  + zpftrs, zpot01, zpot02, zpot03, zpotri, zpotrf,
308  + ztrttf
309 * ..
310 * .. Scalars in Common ..
311  CHARACTER*32 SRNAMT
312 * ..
313 * .. Common blocks ..
314  COMMON / srnamc / srnamt
315 * ..
316 * .. Data statements ..
317  DATA iseedy / 1988, 1989, 1990, 1991 /
318  DATA uplos / 'U', 'L' /
319  DATA forms / 'N', 'C' /
320 * ..
321 * .. Executable Statements ..
322 *
323 * Initialize constants and the random number seed.
324 *
325  nrun = 0
326  nfail = 0
327  nerrs = 0
328  DO 10 i = 1, 4
329  iseed( i ) = iseedy( i )
330  10 CONTINUE
331 *
332  DO 130 iin = 1, nn
333 *
334  n = nval( iin )
335  lda = max( n, 1 )
336  ldb = max( n, 1 )
337 *
338  DO 980 iis = 1, nns
339 *
340  nrhs = nsval( iis )
341 *
342  DO 120 iit = 1, nnt
343 *
344  imat = ntval( iit )
345 *
346 * If N.EQ.0, only consider the first type
347 *
348  IF( n.EQ.0 .AND. iit.GE.1 ) GO TO 120
349 *
350 * Skip types 3, 4, or 5 if the matrix size is too small.
351 *
352  IF( imat.EQ.4 .AND. n.LE.1 ) GO TO 120
353  IF( imat.EQ.5 .AND. n.LE.2 ) GO TO 120
354 *
355 * Do first for UPLO = 'U', then for UPLO = 'L'
356 *
357  DO 110 iuplo = 1, 2
358  uplo = uplos( iuplo )
359 *
360 * Do first for CFORM = 'N', then for CFORM = 'C'
361 *
362  DO 100 iform = 1, 2
363  cform = forms( iform )
364 *
365 * Set up parameters with ZLATB4 and generate a test
366 * matrix with ZLATMS.
367 *
368  CALL zlatb4( 'ZPO', imat, n, n, ctype, kl, ku,
369  + anorm, mode, cndnum, dist )
370 *
371  srnamt = 'ZLATMS'
372  CALL zlatms( n, n, dist, iseed, ctype,
373  + d_work_zlatms,
374  + mode, cndnum, anorm, kl, ku, uplo, a,
375  + lda, z_work_zlatms, info )
376 *
377 * Check error code from ZLATMS.
378 *
379  IF( info.NE.0 ) THEN
380  CALL alaerh( 'ZPF', 'ZLATMS', info, 0, uplo, n,
381  + n, -1, -1, -1, iit, nfail, nerrs,
382  + nout )
383  GO TO 100
384  END IF
385 *
386 * For types 3-5, zero one row and column of the matrix to
387 * test that INFO is returned correctly.
388 *
389  zerot = imat.GE.3 .AND. imat.LE.5
390  IF( zerot ) THEN
391  IF( iit.EQ.3 ) THEN
392  izero = 1
393  ELSE IF( iit.EQ.4 ) THEN
394  izero = n
395  ELSE
396  izero = n / 2 + 1
397  END IF
398  ioff = ( izero-1 )*lda
399 *
400 * Set row and column IZERO of A to 0.
401 *
402  IF( iuplo.EQ.1 ) THEN
403  DO 20 i = 1, izero - 1
404  a( ioff+i ) = zero
405  20 CONTINUE
406  ioff = ioff + izero
407  DO 30 i = izero, n
408  a( ioff ) = zero
409  ioff = ioff + lda
410  30 CONTINUE
411  ELSE
412  ioff = izero
413  DO 40 i = 1, izero - 1
414  a( ioff ) = zero
415  ioff = ioff + lda
416  40 CONTINUE
417  ioff = ioff - izero
418  DO 50 i = izero, n
419  a( ioff+i ) = zero
420  50 CONTINUE
421  END IF
422  ELSE
423  izero = 0
424  END IF
425 *
426 * Set the imaginary part of the diagonals.
427 *
428  CALL zlaipd( n, a, lda+1, 0 )
429 *
430 * Save a copy of the matrix A in ASAV.
431 *
432  CALL zlacpy( uplo, n, n, a, lda, asav, lda )
433 *
434 * Compute the condition number of A (RCONDC).
435 *
436  IF( zerot ) THEN
437  rcondc = zero
438  ELSE
439 *
440 * Compute the 1-norm of A.
441 *
442  anorm = zlanhe( '1', uplo, n, a, lda,
443  + d_work_zlanhe )
444 *
445 * Factor the matrix A.
446 *
447  CALL zpotrf( uplo, n, a, lda, info )
448 *
449 * Form the inverse of A.
450 *
451  CALL zpotri( uplo, n, a, lda, info )
452 
453  IF ( n .NE. 0 ) THEN
454 *
455 * Compute the 1-norm condition number of A.
456 *
457  ainvnm = zlanhe( '1', uplo, n, a, lda,
458  + d_work_zlanhe )
459  rcondc = ( one / anorm ) / ainvnm
460 *
461 * Restore the matrix A.
462 *
463  CALL zlacpy( uplo, n, n, asav, lda, a, lda )
464  END IF
465 *
466  END IF
467 *
468 * Form an exact solution and set the right hand side.
469 *
470  srnamt = 'ZLARHS'
471  CALL zlarhs( 'ZPO', 'N', uplo, ' ', n, n, kl, ku,
472  + nrhs, a, lda, xact, lda, b, lda,
473  + iseed, info )
474  CALL zlacpy( 'Full', n, nrhs, b, lda, bsav, lda )
475 *
476 * Compute the L*L' or U'*U factorization of the
477 * matrix and solve the system.
478 *
479  CALL zlacpy( uplo, n, n, a, lda, afac, lda )
480  CALL zlacpy( 'Full', n, nrhs, b, ldb, x, ldb )
481 *
482  srnamt = 'ZTRTTF'
483  CALL ztrttf( cform, uplo, n, afac, lda, arf, info )
484  srnamt = 'ZPFTRF'
485  CALL zpftrf( cform, uplo, n, arf, info )
486 *
487 * Check error code from ZPFTRF.
488 *
489  IF( info.NE.izero ) THEN
490 *
491 * LANGOU: there is a small hick here: IZERO should
492 * always be INFO however if INFO is ZERO, ALAERH does not
493 * complain.
494 *
495  CALL alaerh( 'ZPF', 'ZPFSV ', info, izero,
496  + uplo, n, n, -1, -1, nrhs, iit,
497  + nfail, nerrs, nout )
498  GO TO 100
499  END IF
500 *
501 * Skip the tests if INFO is not 0.
502 *
503  IF( info.NE.0 ) THEN
504  GO TO 100
505  END IF
506 *
507  srnamt = 'ZPFTRS'
508  CALL zpftrs( cform, uplo, n, nrhs, arf, x, ldb,
509  + info )
510 *
511  srnamt = 'ZTFTTR'
512  CALL ztfttr( cform, uplo, n, arf, afac, lda, info )
513 *
514 * Reconstruct matrix from factors and compute
515 * residual.
516 *
517  CALL zlacpy( uplo, n, n, afac, lda, asav, lda )
518  CALL zpot01( uplo, n, a, lda, afac, lda,
519  + d_work_zpot01, result( 1 ) )
520  CALL zlacpy( uplo, n, n, asav, lda, afac, lda )
521 *
522 * Form the inverse and compute the residual.
523 *
524  IF(mod(n,2).EQ.0)THEN
525  CALL zlacpy( 'A', n+1, n/2, arf, n+1, arfinv,
526  + n+1 )
527  ELSE
528  CALL zlacpy( 'A', n, (n+1)/2, arf, n, arfinv,
529  + n )
530  END IF
531 *
532  srnamt = 'ZPFTRI'
533  CALL zpftri( cform, uplo, n, arfinv , info )
534 *
535  srnamt = 'ZTFTTR'
536  CALL ztfttr( cform, uplo, n, arfinv, ainv, lda,
537  + info )
538 *
539 * Check error code from ZPFTRI.
540 *
541  IF( info.NE.0 )
542  + CALL alaerh( 'ZPO', 'ZPFTRI', info, 0, uplo, n,
543  + n, -1, -1, -1, imat, nfail, nerrs,
544  + nout )
545 *
546  CALL zpot03( uplo, n, a, lda, ainv, lda,
547  + z_work_zpot03, lda, d_work_zpot03,
548  + rcondc, result( 2 ) )
549 *
550 * Compute residual of the computed solution.
551 *
552  CALL zlacpy( 'Full', n, nrhs, b, lda,
553  + z_work_zpot02, lda )
554  CALL zpot02( uplo, n, nrhs, a, lda, x, lda,
555  + z_work_zpot02, lda, d_work_zpot02,
556  + result( 3 ) )
557 *
558 * Check solution from generated exact solution.
559 *
560  CALL zget04( n, nrhs, x, lda, xact, lda, rcondc,
561  + result( 4 ) )
562  nt = 4
563 *
564 * Print information about the tests that did not
565 * pass the threshold.
566 *
567  DO 60 k = 1, nt
568  IF( result( k ).GE.thresh ) THEN
569  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
570  + CALL aladhd( nout, 'ZPF' )
571  WRITE( nout, fmt = 9999 )'ZPFSV ', uplo,
572  + n, iit, k, result( k )
573  nfail = nfail + 1
574  END IF
575  60 CONTINUE
576  nrun = nrun + nt
577  100 CONTINUE
578  110 CONTINUE
579  120 CONTINUE
580  980 CONTINUE
581  130 CONTINUE
582 *
583 * Print a summary of the results.
584 *
585  CALL alasvm( 'ZPF', nout, nfail, nrun, nerrs )
586 *
587  9999 FORMAT( 1x, a6, ', UPLO=''', a1, ''', N =', i5, ', type ', i1,
588  + ', test(', i1, ')=', g12.5 )
589 *
590  RETURN
591 *
592 * End of ZDRVRFP
593 *
594  END
zpotrf
subroutine zpotrf(UPLO, N, A, LDA, INFO)
ZPOTRF VARIANT: right looking block version of the algorithm, calling Level 3 BLAS.
Definition: zpotrf.f:102
alasvm
subroutine alasvm(TYPE, NOUT, NFAIL, NRUN, NERRS)
ALASVM
Definition: alasvm.f:75
alaerh
subroutine alaerh(PATH, SUBNAM, INFO, INFOE, OPTS, M, N, KL, KU, N5, IMAT, NFAIL, NERRS, NOUT)
ALAERH
Definition: alaerh.f:149
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:105
zget04
subroutine zget04(N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID)
ZGET04
Definition: zget04.f:104
zpot02
subroutine zpot02(UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZPOT02
Definition: zpot02.f:129
zpftrf
subroutine zpftrf(TRANSR, UPLO, N, A, INFO)
ZPFTRF
Definition: zpftrf.f:213
zlarhs
subroutine zlarhs(PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO)
ZLARHS
Definition: zlarhs.f:211
zpot03
subroutine zpot03(UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID)
ZPOT03
Definition: zpot03.f:128
zlatb4
subroutine zlatb4(PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
ZLATB4
Definition: zlatb4.f:123
ztfttr
subroutine ztfttr(TRANSR, UPLO, N, ARF, A, LDA, INFO)
ZTFTTR copies a triangular matrix from the rectangular full packed format (TF) to the standard full f...
Definition: ztfttr.f:218
zdrvrfp
subroutine zdrvrfp(NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL, THRESH, A, ASAV, AFAC, AINV, B, BSAV, XACT, X, ARF, ARFINV, Z_WORK_ZLATMS, Z_WORK_ZPOT02, Z_WORK_ZPOT03, D_WORK_ZLATMS, D_WORK_ZLANHE, D_WORK_ZPOT01, D_WORK_ZPOT02, D_WORK_ZPOT03)
ZDRVRFP
Definition: zdrvrfp.f:246
zpftri
subroutine zpftri(TRANSR, UPLO, N, A, INFO)
ZPFTRI
Definition: zpftri.f:214
zlaipd
subroutine zlaipd(N, A, INDA, VINDA)
ZLAIPD
Definition: zlaipd.f:85
aladhd
subroutine aladhd(IOUNIT, PATH)
ALADHD
Definition: aladhd.f:80
zpot01
subroutine zpot01(UPLO, N, A, LDA, AFAC, LDAFAC, RWORK, RESID)
ZPOT01
Definition: zpot01.f:108
ztrttf
subroutine ztrttf(TRANSR, UPLO, N, A, LDA, ARF, INFO)
ZTRTTF copies a triangular matrix from the standard full format (TR) to the rectangular full packed f...
Definition: ztrttf.f:218
zlatms
subroutine zlatms(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, KL, KU, PACK, A, LDA, WORK, INFO)
ZLATMS
Definition: zlatms.f:334
zpftrs
subroutine zpftrs(TRANSR, UPLO, N, NRHS, A, B, LDB, INFO)
ZPFTRS
Definition: zpftrs.f:222
zpotri
subroutine zpotri(UPLO, N, A, LDA, INFO)
ZPOTRI
Definition: zpotri.f:97