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

◆ sdrvpo()

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

SDRVPOX

Purpose:
 SDRVPO tests the driver routines SPOSV, -SVX, and -SVXX.

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

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