LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ 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 
)

CDRVPO

CDRVPOX

Purpose:
 CDRVPO tests the driver routines CPOSV and -SVX.
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.
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 156 of file cdrvpo.f.

159 *
160 * -- LAPACK test routine --
161 * -- LAPACK is a software package provided by Univ. of Tennessee, --
162 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
163 *
164 * .. Scalar Arguments ..
165  LOGICAL TSTERR
166  INTEGER NMAX, NN, NOUT, NRHS
167  REAL THRESH
168 * ..
169 * .. Array Arguments ..
170  LOGICAL DOTYPE( * )
171  INTEGER NVAL( * )
172  REAL RWORK( * ), S( * )
173  COMPLEX A( * ), AFAC( * ), ASAV( * ), B( * ),
174  $ BSAV( * ), WORK( * ), X( * ), XACT( * )
175 * ..
176 *
177 * =====================================================================
178 *
179 * .. Parameters ..
180  REAL ONE, ZERO
181  parameter( one = 1.0e+0, zero = 0.0e+0 )
182  INTEGER NTYPES
183  parameter( ntypes = 9 )
184  INTEGER NTESTS
185  parameter( ntests = 6 )
186 * ..
187 * .. Local Scalars ..
188  LOGICAL EQUIL, NOFACT, PREFAC, ZEROT
189  CHARACTER DIST, EQUED, FACT, TYPE, UPLO, XTYPE
190  CHARACTER*3 PATH
191  INTEGER I, IEQUED, IFACT, IMAT, IN, INFO, IOFF, IUPLO,
192  $ IZERO, K, K1, KL, KU, LDA, MODE, N, NB, NBMIN,
193  $ NERRS, NFACT, NFAIL, NIMAT, NRUN, NT
194  REAL AINVNM, AMAX, ANORM, CNDNUM, RCOND, RCONDC,
195  $ ROLDC, SCOND
196 * ..
197 * .. Local Arrays ..
198  CHARACTER EQUEDS( 2 ), FACTS( 3 ), UPLOS( 2 )
199  INTEGER ISEED( 4 ), ISEEDY( 4 )
200  REAL RESULT( NTESTS )
201 * ..
202 * .. External Functions ..
203  LOGICAL LSAME
204  REAL CLANHE, SGET06
205  EXTERNAL lsame, clanhe, sget06
206 * ..
207 * .. External Subroutines ..
208  EXTERNAL aladhd, alaerh, alasvm, cerrvx, cget04, clacpy,
211  $ cpotrf, cpotri, xlaenv
212 * ..
213 * .. Scalars in Common ..
214  LOGICAL LERR, OK
215  CHARACTER*32 SRNAMT
216  INTEGER INFOT, NUNIT
217 * ..
218 * .. Common blocks ..
219  COMMON / infoc / infot, nunit, ok, lerr
220  COMMON / srnamc / srnamt
221 * ..
222 * .. Intrinsic Functions ..
223  INTRINSIC cmplx, max
224 * ..
225 * .. Data statements ..
226  DATA iseedy / 1988, 1989, 1990, 1991 /
227  DATA uplos / 'U', 'L' /
228  DATA facts / 'F', 'N', 'E' /
229  DATA equeds / 'N', 'Y' /
230 * ..
231 * .. Executable Statements ..
232 *
233 * Initialize constants and the random number seed.
234 *
235  path( 1: 1 ) = 'Complex precision'
236  path( 2: 3 ) = 'PO'
237  nrun = 0
238  nfail = 0
239  nerrs = 0
240  DO 10 i = 1, 4
241  iseed( i ) = iseedy( i )
242  10 CONTINUE
243 *
244 * Test the error exits
245 *
246  IF( tsterr )
247  $ CALL cerrvx( path, nout )
248  infot = 0
249 *
250 * Set the block size and minimum block size for testing.
251 *
252  nb = 1
253  nbmin = 2
254  CALL xlaenv( 1, nb )
255  CALL xlaenv( 2, nbmin )
256 *
257 * Do for each value of N in NVAL
258 *
259  DO 130 in = 1, nn
260  n = nval( in )
261  lda = max( n, 1 )
262  xtype = 'N'
263  nimat = ntypes
264  IF( n.LE.0 )
265  $ nimat = 1
266 *
267  DO 120 imat = 1, nimat
268 *
269 * Do the tests only if DOTYPE( IMAT ) is true.
270 *
271  IF( .NOT.dotype( imat ) )
272  $ GO TO 120
273 *
274 * Skip types 3, 4, or 5 if the matrix size is too small.
275 *
276  zerot = imat.GE.3 .AND. imat.LE.5
277  IF( zerot .AND. n.LT.imat-2 )
278  $ GO TO 120
279 *
280 * Do first for UPLO = 'U', then for UPLO = 'L'
281 *
282  DO 110 iuplo = 1, 2
283  uplo = uplos( iuplo )
284 *
285 * Set up parameters with CLATB4 and generate a test matrix
286 * with CLATMS.
287 *
288  CALL clatb4( path, imat, n, n, TYPE, KL, KU, ANORM, MODE,
289  $ CNDNUM, DIST )
290 *
291  srnamt = 'CLATMS'
292  CALL clatms( n, n, dist, iseed, TYPE, RWORK, MODE,
293  $ CNDNUM, ANORM, KL, KU, UPLO, A, LDA, WORK,
294  $ INFO )
295 *
296 * Check error code from CLATMS.
297 *
298  IF( info.NE.0 ) THEN
299  CALL alaerh( path, 'CLATMS', info, 0, uplo, n, n, -1,
300  $ -1, -1, imat, nfail, nerrs, nout )
301  GO TO 110
302  END IF
303 *
304 * For types 3-5, zero one row and column of the matrix to
305 * test that INFO is returned correctly.
306 *
307  IF( zerot ) THEN
308  IF( imat.EQ.3 ) THEN
309  izero = 1
310  ELSE IF( imat.EQ.4 ) THEN
311  izero = n
312  ELSE
313  izero = n / 2 + 1
314  END IF
315  ioff = ( izero-1 )*lda
316 *
317 * Set row and column IZERO of A to 0.
318 *
319  IF( iuplo.EQ.1 ) THEN
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  izero = 0
341  END IF
342 *
343 * Set the imaginary part of the diagonals.
344 *
345  CALL claipd( n, a, lda+1, 0 )
346 *
347 * Save a copy of the matrix A in ASAV.
348 *
349  CALL clacpy( uplo, n, n, a, lda, asav, lda )
350 *
351  DO 100 iequed = 1, 2
352  equed = equeds( iequed )
353  IF( iequed.EQ.1 ) THEN
354  nfact = 3
355  ELSE
356  nfact = 1
357  END IF
358 *
359  DO 90 ifact = 1, nfact
360  fact = facts( ifact )
361  prefac = lsame( fact, 'F' )
362  nofact = lsame( fact, 'N' )
363  equil = lsame( fact, 'E' )
364 *
365  IF( zerot ) THEN
366  IF( prefac )
367  $ GO TO 90
368  rcondc = zero
369 *
370  ELSE IF( .NOT.lsame( fact, 'N' ) ) THEN
371 *
372 * Compute the condition number for comparison with
373 * the value returned by CPOSVX (FACT = 'N' reuses
374 * the condition number from the previous iteration
375 * with FACT = 'F').
376 *
377  CALL clacpy( uplo, n, n, asav, lda, afac, lda )
378  IF( equil .OR. iequed.GT.1 ) THEN
379 *
380 * Compute row and column scale factors to
381 * equilibrate the matrix A.
382 *
383  CALL cpoequ( n, afac, lda, s, scond, amax,
384  $ info )
385  IF( info.EQ.0 .AND. n.GT.0 ) THEN
386  IF( iequed.GT.1 )
387  $ scond = zero
388 *
389 * Equilibrate the matrix.
390 *
391  CALL claqhe( uplo, n, afac, lda, s, scond,
392  $ amax, equed )
393  END IF
394  END IF
395 *
396 * Save the condition number of the
397 * non-equilibrated system for use in CGET04.
398 *
399  IF( equil )
400  $ roldc = rcondc
401 *
402 * Compute the 1-norm of A.
403 *
404  anorm = clanhe( '1', uplo, n, afac, lda, rwork )
405 *
406 * Factor the matrix A.
407 *
408  CALL cpotrf( uplo, n, afac, lda, info )
409 *
410 * Form the inverse of A.
411 *
412  CALL clacpy( uplo, n, n, afac, lda, a, lda )
413  CALL cpotri( uplo, n, a, lda, info )
414 *
415 * Compute the 1-norm condition number of A.
416 *
417  ainvnm = clanhe( '1', uplo, n, a, lda, rwork )
418  IF( anorm.LE.zero .OR. ainvnm.LE.zero ) THEN
419  rcondc = one
420  ELSE
421  rcondc = ( one / anorm ) / ainvnm
422  END IF
423  END IF
424 *
425 * Restore the matrix A.
426 *
427  CALL clacpy( uplo, n, n, asav, lda, a, lda )
428 *
429 * Form an exact solution and set the right hand side.
430 *
431  srnamt = 'CLARHS'
432  CALL clarhs( path, xtype, uplo, ' ', n, n, kl, ku,
433  $ nrhs, a, lda, xact, lda, b, lda,
434  $ iseed, info )
435  xtype = 'C'
436  CALL clacpy( 'Full', n, nrhs, b, lda, bsav, lda )
437 *
438  IF( nofact ) THEN
439 *
440 * --- Test CPOSV ---
441 *
442 * Compute the L*L' or U'*U factorization of the
443 * matrix and solve the system.
444 *
445  CALL clacpy( uplo, n, n, a, lda, afac, lda )
446  CALL clacpy( 'Full', n, nrhs, b, lda, x, lda )
447 *
448  srnamt = 'CPOSV '
449  CALL cposv( uplo, n, nrhs, afac, lda, x, lda,
450  $ info )
451 *
452 * Check error code from CPOSV .
453 *
454  IF( info.NE.izero ) THEN
455  CALL alaerh( path, 'CPOSV ', info, izero,
456  $ uplo, n, n, -1, -1, nrhs, imat,
457  $ nfail, nerrs, nout )
458  GO TO 70
459  ELSE IF( info.NE.0 ) THEN
460  GO TO 70
461  END IF
462 *
463 * Reconstruct matrix from factors and compute
464 * residual.
465 *
466  CALL cpot01( uplo, n, a, lda, afac, lda, rwork,
467  $ result( 1 ) )
468 *
469 * Compute residual of the computed solution.
470 *
471  CALL clacpy( 'Full', n, nrhs, b, lda, work,
472  $ lda )
473  CALL cpot02( uplo, n, nrhs, a, lda, x, lda,
474  $ work, lda, rwork, result( 2 ) )
475 *
476 * Check solution from generated exact solution.
477 *
478  CALL cget04( n, nrhs, x, lda, xact, lda, rcondc,
479  $ result( 3 ) )
480  nt = 3
481 *
482 * Print information about the tests that did not
483 * pass the threshold.
484 *
485  DO 60 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 )'CPOSV ', uplo,
490  $ n, imat, k, result( k )
491  nfail = nfail + 1
492  END IF
493  60 CONTINUE
494  nrun = nrun + nt
495  70 CONTINUE
496  END IF
497 *
498 * --- Test CPOSVX ---
499 *
500  IF( .NOT.prefac )
501  $ CALL claset( uplo, n, n, cmplx( zero ),
502  $ cmplx( zero ), afac, lda )
503  CALL claset( 'Full', n, nrhs, cmplx( zero ),
504  $ cmplx( zero ), x, lda )
505  IF( iequed.GT.1 .AND. n.GT.0 ) THEN
506 *
507 * Equilibrate the matrix if FACT='F' and
508 * EQUED='Y'.
509 *
510  CALL claqhe( uplo, n, a, lda, s, scond, amax,
511  $ equed )
512  END IF
513 *
514 * Solve the system and compute the condition number
515 * and error bounds using CPOSVX.
516 *
517  srnamt = 'CPOSVX'
518  CALL cposvx( fact, uplo, n, nrhs, a, lda, afac,
519  $ lda, equed, s, b, lda, x, lda, rcond,
520  $ rwork, rwork( nrhs+1 ), work,
521  $ rwork( 2*nrhs+1 ), info )
522 *
523 * Check the error code from CPOSVX.
524 *
525  IF( info.NE.izero ) THEN
526  CALL alaerh( path, 'CPOSVX', info, izero,
527  $ fact // uplo, n, n, -1, -1, nrhs,
528  $ imat, nfail, nerrs, nout )
529  GO TO 90
530  END IF
531 *
532  IF( info.EQ.0 ) THEN
533  IF( .NOT.prefac ) THEN
534 *
535 * Reconstruct matrix from factors and compute
536 * residual.
537 *
538  CALL cpot01( uplo, n, a, lda, afac, lda,
539  $ rwork( 2*nrhs+1 ), result( 1 ) )
540  k1 = 1
541  ELSE
542  k1 = 2
543  END IF
544 *
545 * Compute residual of the computed solution.
546 *
547  CALL clacpy( 'Full', n, nrhs, bsav, lda, work,
548  $ lda )
549  CALL cpot02( uplo, n, nrhs, asav, lda, x, lda,
550  $ work, lda, rwork( 2*nrhs+1 ),
551  $ result( 2 ) )
552 *
553 * Check solution from generated exact solution.
554 *
555  IF( nofact .OR. ( prefac .AND. lsame( equed,
556  $ 'N' ) ) ) THEN
557  CALL cget04( n, nrhs, x, lda, xact, lda,
558  $ rcondc, result( 3 ) )
559  ELSE
560  CALL cget04( n, nrhs, x, lda, xact, lda,
561  $ roldc, result( 3 ) )
562  END IF
563 *
564 * Check the error bounds from iterative
565 * refinement.
566 *
567  CALL cpot05( uplo, n, nrhs, asav, lda, b, lda,
568  $ x, lda, xact, lda, rwork,
569  $ rwork( nrhs+1 ), result( 4 ) )
570  ELSE
571  k1 = 6
572  END IF
573 *
574 * Compare RCOND from CPOSVX with the computed value
575 * in RCONDC.
576 *
577  result( 6 ) = sget06( rcond, rcondc )
578 *
579 * Print information about the tests that did not pass
580 * the threshold.
581 *
582  DO 80 k = k1, 6
583  IF( result( k ).GE.thresh ) THEN
584  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
585  $ CALL aladhd( nout, path )
586  IF( prefac ) THEN
587  WRITE( nout, fmt = 9997 )'CPOSVX', fact,
588  $ uplo, n, equed, imat, k, result( k )
589  ELSE
590  WRITE( nout, fmt = 9998 )'CPOSVX', fact,
591  $ uplo, n, imat, k, result( k )
592  END IF
593  nfail = nfail + 1
594  END IF
595  80 CONTINUE
596  nrun = nrun + 7 - k1
597  90 CONTINUE
598  100 CONTINUE
599  110 CONTINUE
600  120 CONTINUE
601  130 CONTINUE
602 *
603 * Print a summary of the results.
604 *
605  CALL alasvm( path, nout, nfail, nrun, nerrs )
606 *
607  9999 FORMAT( 1x, a, ', UPLO=''', a1, ''', N =', i5, ', type ', i1,
608  $ ', test(', i1, ')=', g12.5 )
609  9998 FORMAT( 1x, a, ', FACT=''', a1, ''', UPLO=''', a1, ''', N=', i5,
610  $ ', type ', i1, ', test(', i1, ')=', g12.5 )
611  9997 FORMAT( 1x, a, ', FACT=''', a1, ''', UPLO=''', a1, ''', N=', i5,
612  $ ', EQUED=''', a1, ''', type ', i1, ', test(', i1, ') =',
613  $ g12.5 )
614  RETURN
615 *
616 * End of CDRVPO
617 *
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine alasvm(TYPE, NOUT, NFAIL, NRUN, NERRS)
ALASVM
Definition: alasvm.f:73
subroutine xlaenv(ISPEC, NVALUE)
XLAENV
Definition: xlaenv.f:81
subroutine aladhd(IOUNIT, PATH)
ALADHD
Definition: aladhd.f:90
subroutine alaerh(PATH, SUBNAM, INFO, INFOE, OPTS, M, N, KL, KU, N5, IMAT, NFAIL, NERRS, NOUT)
ALAERH
Definition: alaerh.f:147
subroutine clarhs(PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO)
CLARHS
Definition: clarhs.f:208
subroutine cpot05(UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
CPOT05
Definition: cpot05.f:165
subroutine clatb4(PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
CLATB4
Definition: clatb4.f:121
subroutine cget04(N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID)
CGET04
Definition: cget04.f:102
subroutine claipd(N, A, INDA, VINDA)
CLAIPD
Definition: claipd.f:83
subroutine cpot01(UPLO, N, A, LDA, AFAC, LDAFAC, RWORK, RESID)
CPOT01
Definition: cpot01.f:106
subroutine cpot02(UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
CPOT02
Definition: cpot02.f:127
subroutine cerrvx(PATH, NUNIT)
CERRVX
Definition: cerrvx.f:55
subroutine clatms(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, KL, KU, PACK, A, LDA, WORK, INFO)
CLATMS
Definition: clatms.f:332
subroutine claqhe(UPLO, N, A, LDA, S, SCOND, AMAX, EQUED)
CLAQHE scales a Hermitian matrix.
Definition: claqhe.f:134
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
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
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
subroutine cpoequ(N, A, LDA, S, SCOND, AMAX, INFO)
CPOEQU
Definition: cpoequ.f:113
subroutine cpotrf(UPLO, N, A, LDA, INFO)
CPOTRF
Definition: cpotrf.f:107
subroutine cpotri(UPLO, N, A, LDA, INFO)
CPOTRI
Definition: cpotri.f:95
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
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
real function sget06(RCOND, RCONDC)
SGET06
Definition: sget06.f:55
Here is the call graph for this function:
Here is the caller graph for this function: