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

◆ cdrvpo()

subroutine cdrvpo ( logical, dimension( * )  dotype,
integer  nn,
integer, dimension( * )  nval,
integer  nrhs,
real  thresh,
logical  tsterr,
integer  nmax,
complex, dimension( * )  a,
complex, dimension( * )  afac,
complex, dimension( * )  asav,
complex, dimension( * )  b,
complex, dimension( * )  bsav,
complex, dimension( * )  x,
complex, dimension( * )  xact,
real, dimension( * )  s,
complex, dimension( * )  work,
real, dimension( * )  rwork,
integer  nout 
)

CDRVPOX

Purpose:
 CDRVPO tests the driver routines CPOSV, -SVX, and -SVXX.

 Note that this file is used only when the XBLAS are available,
 otherwise cdrvpo.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 REAL
          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 array, dimension (NMAX*NMAX)
[out]AFAC
          AFAC is COMPLEX array, dimension (NMAX*NMAX)
[out]ASAV
          ASAV is COMPLEX array, dimension (NMAX*NMAX)
[out]B
          B is COMPLEX array, dimension (NMAX*NRHS)
[out]BSAV
          BSAV is COMPLEX array, dimension (NMAX*NRHS)
[out]X
          X is COMPLEX array, dimension (NMAX*NRHS)
[out]XACT
          XACT is COMPLEX array, dimension (NMAX*NRHS)
[out]S
          S is REAL array, dimension (NMAX)
[out]WORK
          WORK is COMPLEX array, dimension
                      (NMAX*max(3,NRHS))
[out]RWORK
          RWORK is REAL array, dimension (NMAX+2*NRHS)
[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 159 of file cdrvpox.f.

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