LAPACK 3.12.0
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ zdrvhe()

subroutine zdrvhe ( logical, dimension( * )  dotype,
integer  nn,
integer, dimension( * )  nval,
integer  nrhs,
double precision  thresh,
logical  tsterr,
integer  nmax,
complex*16, dimension( * )  a,
complex*16, dimension( * )  afac,
complex*16, dimension( * )  ainv,
complex*16, dimension( * )  b,
complex*16, dimension( * )  x,
complex*16, dimension( * )  xact,
complex*16, dimension( * )  work,
double precision, dimension( * )  rwork,
integer, dimension( * )  iwork,
integer  nout 
)

ZDRVHEX

Purpose:
 ZDRVHE tests the driver routines ZHESV, -SVX, and -SVXX.

 Note that this file is used only when the XBLAS are available,
 otherwise zdrvhe.f defines this subroutine.
Parameters
[in]DOTYPE
          DOTYPE is LOGICAL array, dimension (NTYPES)
          The matrix types to be used for testing.  Matrices of type j
          (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
          .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]NN
          NN is INTEGER
          The number of values of N contained in the vector NVAL.
[in]NVAL
          NVAL is INTEGER array, dimension (NN)
          The values of the matrix dimension N.
[in]NRHS
          NRHS is INTEGER
          The number of right hand side vectors to be generated for
          each linear system.
[in]THRESH
          THRESH is DOUBLE PRECISION
          The threshold value for the test ratios.  A result is
          included in the output file if RESULT >= THRESH.  To have
          every test ratio printed, use THRESH = 0.
[in]TSTERR
          TSTERR is LOGICAL
          Flag that indicates whether error exits are to be tested.
[in]NMAX
          NMAX is INTEGER
          The maximum value permitted for N, used in dimensioning the
          work arrays.
[out]A
          A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]AFAC
          AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]AINV
          AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]B
          B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]X
          X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]XACT
          XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]WORK
          WORK is COMPLEX*16 array, dimension
                      (NMAX*max(2,NRHS))
[out]RWORK
          RWORK is DOUBLE PRECISION array, dimension (2*NMAX+2*NRHS)
[out]IWORK
          IWORK is INTEGER array, dimension (NMAX)
[in]NOUT
          NOUT is INTEGER
          The unit number for output.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 154 of file zdrvhex.f.

157*
158* -- LAPACK test routine --
159* -- LAPACK is a software package provided by Univ. of Tennessee, --
160* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
161*
162* .. Scalar Arguments ..
163 LOGICAL TSTERR
164 INTEGER NMAX, NN, NOUT, NRHS
165 DOUBLE PRECISION THRESH
166* ..
167* .. Array Arguments ..
168 LOGICAL DOTYPE( * )
169 INTEGER IWORK( * ), NVAL( * )
170 DOUBLE PRECISION RWORK( * )
171 COMPLEX*16 A( * ), AFAC( * ), AINV( * ), B( * ),
172 $ WORK( * ), X( * ), XACT( * )
173* ..
174*
175* =====================================================================
176*
177* .. Parameters ..
178 DOUBLE PRECISION ONE, ZERO
179 parameter( one = 1.0d+0, zero = 0.0d+0 )
180 INTEGER NTYPES, NTESTS
181 parameter( ntypes = 10, ntests = 6 )
182 INTEGER NFACT
183 parameter( nfact = 2 )
184* ..
185* .. Local Scalars ..
186 LOGICAL ZEROT
187 CHARACTER DIST, EQUED, FACT, TYPE, UPLO, XTYPE
188 CHARACTER*3 PATH
189 INTEGER I, I1, I2, IFACT, IMAT, IN, INFO, IOFF, IUPLO,
190 $ IZERO, J, K, K1, KL, KU, LDA, LWORK, MODE, N,
191 $ NB, NBMIN, NERRS, NFAIL, NIMAT, NRUN, NT,
192 $ N_ERR_BNDS
193 DOUBLE PRECISION AINVNM, ANORM, CNDNUM, RCOND, RCONDC,
194 $ RPVGRW_SVXX
195* ..
196* .. Local Arrays ..
197 CHARACTER FACTS( NFACT ), UPLOS( 2 )
198 INTEGER ISEED( 4 ), ISEEDY( 4 )
199 DOUBLE PRECISION RESULT( NTESTS ), BERR( NRHS ),
200 $ ERRBNDS_N( NRHS, 3 ), ERRBNDS_C( NRHS, 3 )
201* ..
202* .. External Functions ..
203 DOUBLE PRECISION DGET06, ZLANHE
204 EXTERNAL dget06, zlanhe
205* ..
206* .. External Subroutines ..
207 EXTERNAL aladhd, alaerh, alasvm, xlaenv, zerrvx, zget04,
208 $ zhesv, zhesvx, zhet01, zhetrf, zhetri2, zlacpy,
209 $ zlaipd, zlarhs, zlaset, zlatb4, zlatms, zpot02,
210 $ zpot05, zhesvxx
211* ..
212* .. Scalars in Common ..
213 LOGICAL LERR, OK
214 CHARACTER*32 SRNAMT
215 INTEGER INFOT, NUNIT
216* ..
217* .. Common blocks ..
218 COMMON / infoc / infot, nunit, ok, lerr
219 COMMON / srnamc / srnamt
220* ..
221* .. Intrinsic Functions ..
222 INTRINSIC dcmplx, max, min
223* ..
224* .. Data statements ..
225 DATA iseedy / 1988, 1989, 1990, 1991 /
226 DATA uplos / 'U', 'L' / , facts / 'F', 'N' /
227* ..
228* .. Executable Statements ..
229*
230* Initialize constants and the random number seed.
231*
232 path( 1: 1 ) = 'Z'
233 path( 2: 3 ) = 'HE'
234 nrun = 0
235 nfail = 0
236 nerrs = 0
237 DO 10 i = 1, 4
238 iseed( i ) = iseedy( i )
239 10 CONTINUE
240 lwork = max( 2*nmax, nmax*nrhs )
241*
242* Test the error exits
243*
244 IF( tsterr )
245 $ CALL zerrvx( path, nout )
246 infot = 0
247*
248* Set the block size and minimum block size for testing.
249*
250 nb = 1
251 nbmin = 2
252 CALL xlaenv( 1, nb )
253 CALL xlaenv( 2, nbmin )
254*
255* Do for each value of N in NVAL
256*
257 DO 180 in = 1, nn
258 n = nval( in )
259 lda = max( n, 1 )
260 xtype = 'N'
261 nimat = ntypes
262 IF( n.LE.0 )
263 $ nimat = 1
264*
265 DO 170 imat = 1, nimat
266*
267* Do the tests only if DOTYPE( IMAT ) is true.
268*
269 IF( .NOT.dotype( imat ) )
270 $ GO TO 170
271*
272* Skip types 3, 4, 5, or 6 if the matrix size is too small.
273*
274 zerot = imat.GE.3 .AND. imat.LE.6
275 IF( zerot .AND. n.LT.imat-2 )
276 $ GO TO 170
277*
278* Do first for UPLO = 'U', then for UPLO = 'L'
279*
280 DO 160 iuplo = 1, 2
281 uplo = uplos( iuplo )
282*
283* Set up parameters with ZLATB4 and generate a test matrix
284* with ZLATMS.
285*
286 CALL zlatb4( path, imat, n, n, TYPE, KL, KU, ANORM, MODE,
287 $ CNDNUM, DIST )
288*
289 srnamt = 'ZLATMS'
290 CALL zlatms( n, n, dist, iseed, TYPE, RWORK, MODE,
291 $ CNDNUM, ANORM, KL, KU, UPLO, A, LDA, WORK,
292 $ INFO )
293*
294* Check error code from ZLATMS.
295*
296 IF( info.NE.0 ) THEN
297 CALL alaerh( path, 'ZLATMS', info, 0, uplo, n, n, -1,
298 $ -1, -1, imat, nfail, nerrs, nout )
299 GO TO 160
300 END IF
301*
302* For types 3-6, zero one or more rows and columns of the
303* matrix to test that INFO is returned correctly.
304*
305 IF( zerot ) THEN
306 IF( imat.EQ.3 ) THEN
307 izero = 1
308 ELSE IF( imat.EQ.4 ) THEN
309 izero = n
310 ELSE
311 izero = n / 2 + 1
312 END IF
313*
314 IF( imat.LT.6 ) THEN
315*
316* Set row and column IZERO to zero.
317*
318 IF( iuplo.EQ.1 ) THEN
319 ioff = ( izero-1 )*lda
320 DO 20 i = 1, izero - 1
321 a( ioff+i ) = zero
322 20 CONTINUE
323 ioff = ioff + izero
324 DO 30 i = izero, n
325 a( ioff ) = zero
326 ioff = ioff + lda
327 30 CONTINUE
328 ELSE
329 ioff = izero
330 DO 40 i = 1, izero - 1
331 a( ioff ) = zero
332 ioff = ioff + lda
333 40 CONTINUE
334 ioff = ioff - izero
335 DO 50 i = izero, n
336 a( ioff+i ) = zero
337 50 CONTINUE
338 END IF
339 ELSE
340 ioff = 0
341 IF( iuplo.EQ.1 ) THEN
342*
343* Set the first IZERO rows and columns to zero.
344*
345 DO 70 j = 1, n
346 i2 = min( j, izero )
347 DO 60 i = 1, i2
348 a( ioff+i ) = zero
349 60 CONTINUE
350 ioff = ioff + lda
351 70 CONTINUE
352 ELSE
353*
354* Set the last IZERO rows and columns to zero.
355*
356 DO 90 j = 1, n
357 i1 = max( j, izero )
358 DO 80 i = i1, n
359 a( ioff+i ) = zero
360 80 CONTINUE
361 ioff = ioff + lda
362 90 CONTINUE
363 END IF
364 END IF
365 ELSE
366 izero = 0
367 END IF
368*
369* Set the imaginary part of the diagonals.
370*
371 CALL zlaipd( n, a, lda+1, 0 )
372*
373 DO 150 ifact = 1, nfact
374*
375* Do first for FACT = 'F', then for other values.
376*
377 fact = facts( ifact )
378*
379* Compute the condition number for comparison with
380* the value returned by ZHESVX.
381*
382 IF( zerot ) THEN
383 IF( ifact.EQ.1 )
384 $ GO TO 150
385 rcondc = zero
386*
387 ELSE IF( ifact.EQ.1 ) THEN
388*
389* Compute the 1-norm of A.
390*
391 anorm = zlanhe( '1', uplo, n, a, lda, rwork )
392*
393* Factor the matrix A.
394*
395 CALL zlacpy( uplo, n, n, a, lda, afac, lda )
396 CALL zhetrf( uplo, n, afac, lda, iwork, work,
397 $ lwork, info )
398*
399* Compute inv(A) and take its norm.
400*
401 CALL zlacpy( uplo, n, n, afac, lda, ainv, lda )
402 lwork = (n+nb+1)*(nb+3)
403 CALL zhetri2( uplo, n, ainv, lda, iwork, work,
404 $ lwork, info )
405 ainvnm = zlanhe( '1', uplo, n, ainv, lda, rwork )
406*
407* Compute the 1-norm condition number of A.
408*
409 IF( anorm.LE.zero .OR. ainvnm.LE.zero ) THEN
410 rcondc = one
411 ELSE
412 rcondc = ( one / anorm ) / ainvnm
413 END IF
414 END IF
415*
416* Form an exact solution and set the right hand side.
417*
418 srnamt = 'ZLARHS'
419 CALL zlarhs( path, xtype, uplo, ' ', n, n, kl, ku,
420 $ nrhs, a, lda, xact, lda, b, lda, iseed,
421 $ info )
422 xtype = 'C'
423*
424* --- Test ZHESV ---
425*
426 IF( ifact.EQ.2 ) THEN
427 CALL zlacpy( uplo, n, n, a, lda, afac, lda )
428 CALL zlacpy( 'Full', n, nrhs, b, lda, x, lda )
429*
430* Factor the matrix and solve the system using ZHESV.
431*
432 srnamt = 'ZHESV '
433 CALL zhesv( uplo, n, nrhs, afac, lda, iwork, x,
434 $ lda, work, lwork, info )
435*
436* Adjust the expected value of INFO to account for
437* pivoting.
438*
439 k = izero
440 IF( k.GT.0 ) THEN
441 100 CONTINUE
442 IF( iwork( k ).LT.0 ) THEN
443 IF( iwork( k ).NE.-k ) THEN
444 k = -iwork( k )
445 GO TO 100
446 END IF
447 ELSE IF( iwork( k ).NE.k ) THEN
448 k = iwork( k )
449 GO TO 100
450 END IF
451 END IF
452*
453* Check error code from ZHESV .
454*
455 IF( info.NE.k ) THEN
456 CALL alaerh( path, 'ZHESV ', info, k, uplo, n,
457 $ n, -1, -1, nrhs, imat, nfail,
458 $ nerrs, nout )
459 GO TO 120
460 ELSE IF( info.NE.0 ) THEN
461 GO TO 120
462 END IF
463*
464* Reconstruct matrix from factors and compute
465* residual.
466*
467 CALL zhet01( uplo, n, a, lda, afac, lda, iwork,
468 $ ainv, lda, rwork, result( 1 ) )
469*
470* Compute residual of the computed solution.
471*
472 CALL zlacpy( 'Full', n, nrhs, b, lda, work, lda )
473 CALL zpot02( uplo, n, nrhs, a, lda, x, lda, work,
474 $ lda, rwork, result( 2 ) )
475*
476* Check solution from generated exact solution.
477*
478 CALL zget04( n, nrhs, x, lda, xact, lda, rcondc,
479 $ result( 3 ) )
480 nt = 3
481*
482* Print information about the tests that did not pass
483* the threshold.
484*
485 DO 110 k = 1, nt
486 IF( result( k ).GE.thresh ) THEN
487 IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
488 $ CALL aladhd( nout, path )
489 WRITE( nout, fmt = 9999 )'ZHESV ', uplo, n,
490 $ imat, k, result( k )
491 nfail = nfail + 1
492 END IF
493 110 CONTINUE
494 nrun = nrun + nt
495 120 CONTINUE
496 END IF
497*
498* --- Test ZHESVX ---
499*
500 IF( ifact.EQ.2 )
501 $ CALL zlaset( uplo, n, n, dcmplx( zero ),
502 $ dcmplx( zero ), afac, lda )
503 CALL zlaset( 'Full', n, nrhs, dcmplx( zero ),
504 $ dcmplx( zero ), x, lda )
505*
506* Solve the system and compute the condition number and
507* error bounds using ZHESVX.
508*
509 srnamt = 'ZHESVX'
510 CALL zhesvx( fact, uplo, n, nrhs, a, lda, afac, lda,
511 $ iwork, b, lda, x, lda, rcond, rwork,
512 $ rwork( nrhs+1 ), work, lwork,
513 $ rwork( 2*nrhs+1 ), info )
514*
515* Adjust the expected value of INFO to account for
516* pivoting.
517*
518 k = izero
519 IF( k.GT.0 ) THEN
520 130 CONTINUE
521 IF( iwork( k ).LT.0 ) THEN
522 IF( iwork( k ).NE.-k ) THEN
523 k = -iwork( k )
524 GO TO 130
525 END IF
526 ELSE IF( iwork( k ).NE.k ) THEN
527 k = iwork( k )
528 GO TO 130
529 END IF
530 END IF
531*
532* Check the error code from ZHESVX.
533*
534 IF( info.NE.k ) THEN
535 CALL alaerh( path, 'ZHESVX', info, k, fact // uplo,
536 $ n, n, -1, -1, nrhs, imat, nfail,
537 $ nerrs, nout )
538 GO TO 150
539 END IF
540*
541 IF( info.EQ.0 ) THEN
542 IF( ifact.GE.2 ) THEN
543*
544* Reconstruct matrix from factors and compute
545* residual.
546*
547 CALL zhet01( uplo, n, a, lda, afac, lda, iwork,
548 $ ainv, lda, rwork( 2*nrhs+1 ),
549 $ result( 1 ) )
550 k1 = 1
551 ELSE
552 k1 = 2
553 END IF
554*
555* Compute residual of the computed solution.
556*
557 CALL zlacpy( 'Full', n, nrhs, b, lda, work, lda )
558 CALL zpot02( uplo, n, nrhs, a, lda, x, lda, work,
559 $ lda, rwork( 2*nrhs+1 ), result( 2 ) )
560*
561* Check solution from generated exact solution.
562*
563 CALL zget04( n, nrhs, x, lda, xact, lda, rcondc,
564 $ result( 3 ) )
565*
566* Check the error bounds from iterative refinement.
567*
568 CALL zpot05( uplo, n, nrhs, a, lda, b, lda, x, lda,
569 $ xact, lda, rwork, rwork( nrhs+1 ),
570 $ result( 4 ) )
571 ELSE
572 k1 = 6
573 END IF
574*
575* Compare RCOND from ZHESVX with the computed value
576* in RCONDC.
577*
578 result( 6 ) = dget06( rcond, rcondc )
579*
580* Print information about the tests that did not pass
581* the threshold.
582*
583 DO 140 k = k1, 6
584 IF( result( k ).GE.thresh ) THEN
585 IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
586 $ CALL aladhd( nout, path )
587 WRITE( nout, fmt = 9998 )'ZHESVX', fact, uplo,
588 $ n, imat, k, result( k )
589 nfail = nfail + 1
590 END IF
591 140 CONTINUE
592 nrun = nrun + 7 - k1
593*
594* --- Test ZHESVXX ---
595*
596* Restore the matrices A and B.
597*
598 IF( ifact.EQ.2 )
599 $ CALL zlaset( uplo, n, n, dcmplx( zero ),
600 $ dcmplx( zero ), afac, lda )
601 CALL zlaset( 'Full', n, nrhs, dcmplx( zero ),
602 $ dcmplx( zero ), x, lda )
603*
604* Solve the system and compute the condition number
605* and error bounds using ZHESVXX.
606*
607 srnamt = 'ZHESVXX'
608 n_err_bnds = 3
609 equed = 'N'
610 CALL zhesvxx( fact, uplo, n, nrhs, a, lda, afac,
611 $ lda, iwork, equed, work( n+1 ), b, lda, x,
612 $ lda, rcond, rpvgrw_svxx, berr, n_err_bnds,
613 $ errbnds_n, errbnds_c, 0, zero, work,
614 $ rwork(2*nrhs+1), info )
615*
616* Adjust the expected value of INFO to account for
617* pivoting.
618*
619 k = izero
620 IF( k.GT.0 ) THEN
621 135 CONTINUE
622 IF( iwork( k ).LT.0 ) THEN
623 IF( iwork( k ).NE.-k ) THEN
624 k = -iwork( k )
625 GO TO 135
626 END IF
627 ELSE IF( iwork( k ).NE.k ) THEN
628 k = iwork( k )
629 GO TO 135
630 END IF
631 END IF
632*
633* Check the error code from ZHESVXX.
634*
635 IF( info.NE.k .AND. info.LE.n) THEN
636 CALL alaerh( path, 'ZHESVXX', info, k,
637 $ fact // uplo, n, n, -1, -1, nrhs, imat, nfail,
638 $ nerrs, nout )
639 GO TO 150
640 END IF
641*
642 IF( info.EQ.0 ) THEN
643 IF( ifact.GE.2 ) THEN
644*
645* Reconstruct matrix from factors and compute
646* residual.
647*
648 CALL zhet01( uplo, n, a, lda, afac, lda, iwork,
649 $ ainv, lda, rwork(2*nrhs+1),
650 $ result( 1 ) )
651 k1 = 1
652 ELSE
653 k1 = 2
654 END IF
655*
656* Compute residual of the computed solution.
657*
658 CALL zlacpy( 'Full', n, nrhs, b, lda, work, lda )
659 CALL zpot02( uplo, n, nrhs, a, lda, x, lda, work,
660 $ lda, rwork( 2*nrhs+1 ), result( 2 ) )
661 result( 2 ) = 0.0
662*
663* Check solution from generated exact solution.
664*
665 CALL zget04( n, nrhs, x, lda, xact, lda, rcondc,
666 $ result( 3 ) )
667*
668* Check the error bounds from iterative refinement.
669*
670 CALL zpot05( uplo, n, nrhs, a, lda, b, lda, x, lda,
671 $ xact, lda, rwork, rwork( nrhs+1 ),
672 $ result( 4 ) )
673 ELSE
674 k1 = 6
675 END IF
676*
677* Compare RCOND from ZHESVXX with the computed value
678* in RCONDC.
679*
680 result( 6 ) = dget06( rcond, rcondc )
681*
682* Print information about the tests that did not pass
683* the threshold.
684*
685 DO 85 k = k1, 6
686 IF( result( k ).GE.thresh ) THEN
687 IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
688 $ CALL aladhd( nout, path )
689 WRITE( nout, fmt = 9998 )'ZHESVXX',
690 $ fact, uplo, n, imat, k,
691 $ result( k )
692 nfail = nfail + 1
693 END IF
694 85 CONTINUE
695 nrun = nrun + 7 - k1
696*
697 150 CONTINUE
698*
699 160 CONTINUE
700 170 CONTINUE
701 180 CONTINUE
702*
703* Print a summary of the results.
704*
705 CALL alasvm( path, nout, nfail, nrun, nerrs )
706*
707
708* Test Error Bounds from ZHESVXX
709
710 CALL zebchvxx(thresh, path)
711
712 9999 FORMAT( 1x, a, ', UPLO=''', a1, ''', N =', i5, ', type ', i2,
713 $ ', test ', i2, ', ratio =', g12.5 )
714 9998 FORMAT( 1x, a, ', FACT=''', a1, ''', UPLO=''', a1, ''', N =', i5,
715 $ ', type ', i2, ', test ', i2, ', ratio =', g12.5 )
716 RETURN
717*
718* End of ZDRVHEX
719*
alasvm
subroutine alasvm(type, nout, nfail, nrun, nerrs)
ALASVM
Definition alasvm.f:73
xlaenv
subroutine xlaenv(ispec, nvalue)
XLAENV
Definition xlaenv.f:81
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
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
dget06
double precision function dget06(rcond, rcondc)
DGET06
Definition dget06.f:55
zhesv
subroutine zhesv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info)
ZHESV computes the solution to system of linear equations A * X = B for HE matrices
Definition zhesv.f:171
zhesvx
subroutine zhesvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info)
ZHESVX computes the solution to system of linear equations A * X = B for HE matrices
Definition zhesvx.f:285
zhesvxx
subroutine zhesvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, equed, s, b, ldb, x, ldx, rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, rwork, info)
ZHESVXX computes the solution to system of linear equations A * X = B for HE matrices
Definition zhesvxx.f:506
zhetrf
subroutine zhetrf(uplo, n, a, lda, ipiv, work, lwork, info)
ZHETRF
Definition zhetrf.f:177
zhetri2
subroutine zhetri2(uplo, n, a, lda, ipiv, work, lwork, info)
ZHETRI2
Definition zhetri2.f:127
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
zlanhe
double precision function zlanhe(norm, uplo, n, a, lda, work)
ZLANHE returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition zlanhe.f:124
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
zebchvxx
subroutine zebchvxx(thresh, path)
ZEBCHVXX
Definition zebchvxx.f:96
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
zhet01
subroutine zhet01(uplo, n, a, lda, afac, ldafac, ipiv, c, ldc, rwork, resid)
ZHET01
Definition zhet01.f:126
zlaipd
subroutine zlaipd(n, a, inda, vinda)
ZLAIPD
Definition zlaipd.f:83
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
zpot02
subroutine zpot02(uplo, n, nrhs, a, lda, x, ldx, b, ldb, rwork, resid)
ZPOT02
Definition zpot02.f:127
zpot05
subroutine zpot05(uplo, n, nrhs, a, lda, b, ldb, x, ldx, xact, ldxact, ferr, berr, reslts)
ZPOT05
Definition zpot05.f:165
Here is the call graph for this function: