LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
 All Files Functions Groups
ddrvsy.f
Go to the documentation of this file.
1 *> \brief \b DDRVSY
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 DDRVSY( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
12 * A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK,
13 * NOUT )
14 *
15 * .. Scalar Arguments ..
16 * LOGICAL TSTERR
17 * INTEGER NMAX, NN, NOUT, NRHS
18 * DOUBLE PRECISION THRESH
19 * ..
20 * .. Array Arguments ..
21 * LOGICAL DOTYPE( * )
22 * INTEGER IWORK( * ), NVAL( * )
23 * DOUBLE PRECISION A( * ), AFAC( * ), AINV( * ), B( * ),
24 * $ RWORK( * ), WORK( * ), X( * ), XACT( * )
25 * ..
26 *
27 *
28 *> \par Purpose:
29 * =============
30 *>
31 *> \verbatim
32 *>
33 *> DDRVSY tests the driver routines DSYSV and -SVX.
34 *> \endverbatim
35 *
36 * Arguments:
37 * ==========
38 *
39 *> \param[in] DOTYPE
40 *> \verbatim
41 *> DOTYPE is LOGICAL array, dimension (NTYPES)
42 *> The matrix types to be used for testing. Matrices of type j
43 *> (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
44 *> .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
45 *> \endverbatim
46 *>
47 *> \param[in] NN
48 *> \verbatim
49 *> NN is INTEGER
50 *> The number of values of N contained in the vector NVAL.
51 *> \endverbatim
52 *>
53 *> \param[in] NVAL
54 *> \verbatim
55 *> NVAL is INTEGER array, dimension (NN)
56 *> The values of the matrix dimension N.
57 *> \endverbatim
58 *>
59 *> \param[in] NRHS
60 *> \verbatim
61 *> NRHS is INTEGER
62 *> The number of right hand side vectors to be generated for
63 *> each linear system.
64 *> \endverbatim
65 *>
66 *> \param[in] THRESH
67 *> \verbatim
68 *> THRESH is DOUBLE PRECISION
69 *> The threshold value for the test ratios. A result is
70 *> included in the output file if RESULT >= THRESH. To have
71 *> every test ratio printed, use THRESH = 0.
72 *> \endverbatim
73 *>
74 *> \param[in] TSTERR
75 *> \verbatim
76 *> TSTERR is LOGICAL
77 *> Flag that indicates whether error exits are to be tested.
78 *> \endverbatim
79 *>
80 *> \param[in] NMAX
81 *> \verbatim
82 *> NMAX is INTEGER
83 *> The maximum value permitted for N, used in dimensioning the
84 *> work arrays.
85 *> \endverbatim
86 *>
87 *> \param[out] A
88 *> \verbatim
89 *> A is DOUBLE PRECISION array, dimension (NMAX*NMAX)
90 *> \endverbatim
91 *>
92 *> \param[out] AFAC
93 *> \verbatim
94 *> AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX)
95 *> \endverbatim
96 *>
97 *> \param[out] AINV
98 *> \verbatim
99 *> AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX)
100 *> \endverbatim
101 *>
102 *> \param[out] B
103 *> \verbatim
104 *> B is DOUBLE PRECISION array, dimension (NMAX*NRHS)
105 *> \endverbatim
106 *>
107 *> \param[out] X
108 *> \verbatim
109 *> X is DOUBLE PRECISION array, dimension (NMAX*NRHS)
110 *> \endverbatim
111 *>
112 *> \param[out] XACT
113 *> \verbatim
114 *> XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS)
115 *> \endverbatim
116 *>
117 *> \param[out] WORK
118 *> \verbatim
119 *> WORK is DOUBLE PRECISION array, dimension
120 *> (NMAX*max(2,NRHS))
121 *> \endverbatim
122 *>
123 *> \param[out] RWORK
124 *> \verbatim
125 *> RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
126 *> \endverbatim
127 *>
128 *> \param[out] IWORK
129 *> \verbatim
130 *> IWORK is INTEGER array, dimension (2*NMAX)
131 *> \endverbatim
132 *>
133 *> \param[in] NOUT
134 *> \verbatim
135 *> NOUT is INTEGER
136 *> The unit number for output.
137 *> \endverbatim
138 *
139 * Authors:
140 * ========
141 *
142 *> \author Univ. of Tennessee
143 *> \author Univ. of California Berkeley
144 *> \author Univ. of Colorado Denver
145 *> \author NAG Ltd.
146 *
147 *> \date November 2011
148 *
149 *> \ingroup double_lin
150 *
151 * =====================================================================
152  SUBROUTINE ddrvsy( DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX,
153  $ a, afac, ainv, b, x, xact, work, rwork, iwork,
154  $ nout )
155 *
156 * -- LAPACK test routine (version 3.4.0) --
157 * -- LAPACK is a software package provided by Univ. of Tennessee, --
158 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
159 * November 2011
160 *
161 * .. Scalar Arguments ..
162  LOGICAL tsterr
163  INTEGER nmax, nn, nout, nrhs
164  DOUBLE PRECISION thresh
165 * ..
166 * .. Array Arguments ..
167  LOGICAL dotype( * )
168  INTEGER iwork( * ), nval( * )
169  DOUBLE PRECISION a( * ), afac( * ), ainv( * ), b( * ),
170  $ rwork( * ), work( * ), x( * ), xact( * )
171 * ..
172 *
173 * =====================================================================
174 *
175 * .. Parameters ..
176  DOUBLE PRECISION one, zero
177  parameter( one = 1.0d+0, zero = 0.0d+0 )
178  INTEGER ntypes, ntests
179  parameter( ntypes = 10, ntests = 6 )
180  INTEGER nfact
181  parameter( nfact = 2 )
182 * ..
183 * .. Local Scalars ..
184  LOGICAL zerot
185  CHARACTER dist, fact, type, uplo, xtype
186  CHARACTER*3 path
187  INTEGER i, i1, i2, ifact, imat, in, info, ioff, iuplo,
188  $ izero, j, k, k1, kl, ku, lda, lwork, mode, n,
189  $ nb, nbmin, nerrs, nfail, nimat, nrun, nt
190  DOUBLE PRECISION ainvnm, anorm, cndnum, rcond, rcondc
191 * ..
192 * .. Local Arrays ..
193  CHARACTER facts( nfact ), uplos( 2 )
194  INTEGER iseed( 4 ), iseedy( 4 )
195  DOUBLE PRECISION result( ntests )
196 * ..
197 * .. External Functions ..
198  DOUBLE PRECISION dget06, dlansy
199  EXTERNAL dget06, dlansy
200 * ..
201 * .. External Subroutines ..
202  EXTERNAL aladhd, alaerh, alasvm, derrvx, dget04, dlacpy,
205 * ..
206 * .. Scalars in Common ..
207  LOGICAL lerr, ok
208  CHARACTER*32 srnamt
209  INTEGER infot, nunit
210 * ..
211 * .. Common blocks ..
212  COMMON / infoc / infot, nunit, ok, lerr
213  COMMON / srnamc / srnamt
214 * ..
215 * .. Intrinsic Functions ..
216  INTRINSIC max, min
217 * ..
218 * .. Data statements ..
219  DATA iseedy / 1988, 1989, 1990, 1991 /
220  DATA uplos / 'U', 'L' / , facts / 'F', 'N' /
221 * ..
222 * .. Executable Statements ..
223 *
224 * Initialize constants and the random number seed.
225 *
226  path( 1: 1 ) = 'Double precision'
227  path( 2: 3 ) = 'SY'
228  nrun = 0
229  nfail = 0
230  nerrs = 0
231  DO 10 i = 1, 4
232  iseed( i ) = iseedy( i )
233  10 CONTINUE
234  lwork = max( 2*nmax, nmax*nrhs )
235 *
236 * Test the error exits
237 *
238  IF( tsterr )
239  $ CALL derrvx( path, nout )
240  infot = 0
241 *
242 * Set the block size and minimum block size for testing.
243 *
244  nb = 1
245  nbmin = 2
246  CALL xlaenv( 1, nb )
247  CALL xlaenv( 2, nbmin )
248 *
249 * Do for each value of N in NVAL
250 *
251  DO 180 in = 1, nn
252  n = nval( in )
253  lda = max( n, 1 )
254  xtype = 'N'
255  nimat = ntypes
256  IF( n.LE.0 )
257  $ nimat = 1
258 *
259  DO 170 imat = 1, nimat
260 *
261 * Do the tests only if DOTYPE( IMAT ) is true.
262 *
263  IF( .NOT.dotype( imat ) )
264  $ go to 170
265 *
266 * Skip types 3, 4, 5, or 6 if the matrix size is too small.
267 *
268  zerot = imat.GE.3 .AND. imat.LE.6
269  IF( zerot .AND. n.LT.imat-2 )
270  $ go to 170
271 *
272 * Do first for UPLO = 'U', then for UPLO = 'L'
273 *
274  DO 160 iuplo = 1, 2
275  uplo = uplos( iuplo )
276 *
277 * Set up parameters with DLATB4 and generate a test matrix
278 * with DLATMS.
279 *
280  CALL dlatb4( path, imat, n, n, type, kl, ku, anorm, mode,
281  $ cndnum, dist )
282 *
283  srnamt = 'DLATMS'
284  CALL dlatms( n, n, dist, iseed, type, rwork, mode,
285  $ cndnum, anorm, kl, ku, uplo, a, lda, work,
286  $ info )
287 *
288 * Check error code from DLATMS.
289 *
290  IF( info.NE.0 ) THEN
291  CALL alaerh( path, 'DLATMS', info, 0, uplo, n, n, -1,
292  $ -1, -1, imat, nfail, nerrs, nout )
293  go to 160
294  END IF
295 *
296 * For types 3-6, zero one or more rows and columns of the
297 * matrix to test that INFO is returned correctly.
298 *
299  IF( zerot ) THEN
300  IF( imat.EQ.3 ) THEN
301  izero = 1
302  ELSE IF( imat.EQ.4 ) THEN
303  izero = n
304  ELSE
305  izero = n / 2 + 1
306  END IF
307 *
308  IF( imat.LT.6 ) THEN
309 *
310 * Set row and column IZERO to zero.
311 *
312  IF( iuplo.EQ.1 ) THEN
313  ioff = ( izero-1 )*lda
314  DO 20 i = 1, izero - 1
315  a( ioff+i ) = zero
316  20 CONTINUE
317  ioff = ioff + izero
318  DO 30 i = izero, n
319  a( ioff ) = zero
320  ioff = ioff + lda
321  30 CONTINUE
322  ELSE
323  ioff = izero
324  DO 40 i = 1, izero - 1
325  a( ioff ) = zero
326  ioff = ioff + lda
327  40 CONTINUE
328  ioff = ioff - izero
329  DO 50 i = izero, n
330  a( ioff+i ) = zero
331  50 CONTINUE
332  END IF
333  ELSE
334  ioff = 0
335  IF( iuplo.EQ.1 ) THEN
336 *
337 * Set the first IZERO rows and columns to zero.
338 *
339  DO 70 j = 1, n
340  i2 = min( j, izero )
341  DO 60 i = 1, i2
342  a( ioff+i ) = zero
343  60 CONTINUE
344  ioff = ioff + lda
345  70 CONTINUE
346  ELSE
347 *
348 * Set the last IZERO rows and columns to zero.
349 *
350  DO 90 j = 1, n
351  i1 = max( j, izero )
352  DO 80 i = i1, n
353  a( ioff+i ) = zero
354  80 CONTINUE
355  ioff = ioff + lda
356  90 CONTINUE
357  END IF
358  END IF
359  ELSE
360  izero = 0
361  END IF
362 *
363  DO 150 ifact = 1, nfact
364 *
365 * Do first for FACT = 'F', then for other values.
366 *
367  fact = facts( ifact )
368 *
369 * Compute the condition number for comparison with
370 * the value returned by DSYSVX.
371 *
372  IF( zerot ) THEN
373  IF( ifact.EQ.1 )
374  $ go to 150
375  rcondc = zero
376 *
377  ELSE IF( ifact.EQ.1 ) THEN
378 *
379 * Compute the 1-norm of A.
380 *
381  anorm = dlansy( '1', uplo, n, a, lda, rwork )
382 *
383 * Factor the matrix A.
384 *
385  CALL dlacpy( uplo, n, n, a, lda, afac, lda )
386  CALL dsytrf( uplo, n, afac, lda, iwork, work,
387  $ lwork, info )
388 *
389 * Compute inv(A) and take its norm.
390 *
391  CALL dlacpy( uplo, n, n, afac, lda, ainv, lda )
392  lwork = (n+nb+1)*(nb+3)
393  CALL dsytri2( uplo, n, ainv, lda, iwork, work,
394  $ lwork, info )
395  ainvnm = dlansy( '1', uplo, n, ainv, lda, rwork )
396 *
397 * Compute the 1-norm condition number of A.
398 *
399  IF( anorm.LE.zero .OR. ainvnm.LE.zero ) THEN
400  rcondc = one
401  ELSE
402  rcondc = ( one / anorm ) / ainvnm
403  END IF
404  END IF
405 *
406 * Form an exact solution and set the right hand side.
407 *
408  srnamt = 'DLARHS'
409  CALL dlarhs( path, xtype, uplo, ' ', n, n, kl, ku,
410  $ nrhs, a, lda, xact, lda, b, lda, iseed,
411  $ info )
412  xtype = 'C'
413 *
414 * --- Test DSYSV ---
415 *
416  IF( ifact.EQ.2 ) THEN
417  CALL dlacpy( uplo, n, n, a, lda, afac, lda )
418  CALL dlacpy( 'Full', n, nrhs, b, lda, x, lda )
419 *
420 * Factor the matrix and solve the system using DSYSV.
421 *
422  srnamt = 'DSYSV '
423  CALL dsysv( uplo, n, nrhs, afac, lda, iwork, x,
424  $ lda, work, lwork, info )
425 *
426 * Adjust the expected value of INFO to account for
427 * pivoting.
428 *
429  k = izero
430  IF( k.GT.0 ) THEN
431  100 CONTINUE
432  IF( iwork( k ).LT.0 ) THEN
433  IF( iwork( k ).NE.-k ) THEN
434  k = -iwork( k )
435  go to 100
436  END IF
437  ELSE IF( iwork( k ).NE.k ) THEN
438  k = iwork( k )
439  go to 100
440  END IF
441  END IF
442 *
443 * Check error code from DSYSV .
444 *
445  IF( info.NE.k ) THEN
446  CALL alaerh( path, 'DSYSV ', info, k, uplo, n,
447  $ n, -1, -1, nrhs, imat, nfail,
448  $ nerrs, nout )
449  go to 120
450  ELSE IF( info.NE.0 ) THEN
451  go to 120
452  END IF
453 *
454 * Reconstruct matrix from factors and compute
455 * residual.
456 *
457  CALL dsyt01( uplo, n, a, lda, afac, lda, iwork,
458  $ ainv, lda, rwork, result( 1 ) )
459 *
460 * Compute residual of the computed solution.
461 *
462  CALL dlacpy( 'Full', n, nrhs, b, lda, work, lda )
463  CALL dpot02( uplo, n, nrhs, a, lda, x, lda, work,
464  $ lda, rwork, result( 2 ) )
465 *
466 * Check solution from generated exact solution.
467 *
468  CALL dget04( n, nrhs, x, lda, xact, lda, rcondc,
469  $ result( 3 ) )
470  nt = 3
471 *
472 * Print information about the tests that did not pass
473 * the threshold.
474 *
475  DO 110 k = 1, nt
476  IF( result( k ).GE.thresh ) THEN
477  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
478  $ CALL aladhd( nout, path )
479  WRITE( nout, fmt = 9999 )'DSYSV ', uplo, n,
480  $ imat, k, result( k )
481  nfail = nfail + 1
482  END IF
483  110 CONTINUE
484  nrun = nrun + nt
485  120 CONTINUE
486  END IF
487 *
488 * --- Test DSYSVX ---
489 *
490  IF( ifact.EQ.2 )
491  $ CALL dlaset( uplo, n, n, zero, zero, afac, lda )
492  CALL dlaset( 'Full', n, nrhs, zero, zero, x, lda )
493 *
494 * Solve the system and compute the condition number and
495 * error bounds using DSYSVX.
496 *
497  srnamt = 'DSYSVX'
498  CALL dsysvx( fact, uplo, n, nrhs, a, lda, afac, lda,
499  $ iwork, b, lda, x, lda, rcond, rwork,
500  $ rwork( nrhs+1 ), work, lwork,
501  $ iwork( n+1 ), info )
502 *
503 * Adjust the expected value of INFO to account for
504 * pivoting.
505 *
506  k = izero
507  IF( k.GT.0 ) THEN
508  130 CONTINUE
509  IF( iwork( k ).LT.0 ) THEN
510  IF( iwork( k ).NE.-k ) THEN
511  k = -iwork( k )
512  go to 130
513  END IF
514  ELSE IF( iwork( k ).NE.k ) THEN
515  k = iwork( k )
516  go to 130
517  END IF
518  END IF
519 *
520 * Check the error code from DSYSVX.
521 *
522  IF( info.NE.k ) THEN
523  CALL alaerh( path, 'DSYSVX', info, k, fact // uplo,
524  $ n, n, -1, -1, nrhs, imat, nfail,
525  $ nerrs, nout )
526  go to 150
527  END IF
528 *
529  IF( info.EQ.0 ) THEN
530  IF( ifact.GE.2 ) THEN
531 *
532 * Reconstruct matrix from factors and compute
533 * residual.
534 *
535  CALL dsyt01( uplo, n, a, lda, afac, lda, iwork,
536  $ ainv, lda, rwork( 2*nrhs+1 ),
537  $ result( 1 ) )
538  k1 = 1
539  ELSE
540  k1 = 2
541  END IF
542 *
543 * Compute residual of the computed solution.
544 *
545  CALL dlacpy( 'Full', n, nrhs, b, lda, work, lda )
546  CALL dpot02( uplo, n, nrhs, a, lda, x, lda, work,
547  $ lda, rwork( 2*nrhs+1 ), result( 2 ) )
548 *
549 * Check solution from generated exact solution.
550 *
551  CALL dget04( n, nrhs, x, lda, xact, lda, rcondc,
552  $ result( 3 ) )
553 *
554 * Check the error bounds from iterative refinement.
555 *
556  CALL dpot05( uplo, n, nrhs, a, lda, b, lda, x, lda,
557  $ xact, lda, rwork, rwork( nrhs+1 ),
558  $ result( 4 ) )
559  ELSE
560  k1 = 6
561  END IF
562 *
563 * Compare RCOND from DSYSVX with the computed value
564 * in RCONDC.
565 *
566  result( 6 ) = dget06( rcond, rcondc )
567 *
568 * Print information about the tests that did not pass
569 * the threshold.
570 *
571  DO 140 k = k1, 6
572  IF( result( k ).GE.thresh ) THEN
573  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
574  $ CALL aladhd( nout, path )
575  WRITE( nout, fmt = 9998 )'DSYSVX', fact, uplo,
576  $ n, imat, k, result( k )
577  nfail = nfail + 1
578  END IF
579  140 CONTINUE
580  nrun = nrun + 7 - k1
581 *
582  150 CONTINUE
583 *
584  160 CONTINUE
585  170 CONTINUE
586  180 CONTINUE
587 *
588 * Print a summary of the results.
589 *
590  CALL alasvm( path, nout, nfail, nrun, nerrs )
591 *
592  9999 FORMAT( 1x, a, ', UPLO=''', a1, ''', N =', i5, ', type ', i2,
593  $ ', test ', i2, ', ratio =', g12.5 )
594  9998 FORMAT( 1x, a, ', FACT=''', a1, ''', UPLO=''', a1, ''', N =', i5,
595  $ ', type ', i2, ', test ', i2, ', ratio =', g12.5 )
596  RETURN
597 *
598 * End of DDRVSY
599 *
600  END
subroutine alasvm(TYPE, NOUT, NFAIL, NRUN, NERRS)
ALASVM
Definition: alasvm.f:74
subroutine dlaset(UPLO, M, N, ALPHA, BETA, A, LDA)
DLASET
Definition: dlaset.f:111
subroutine alaerh(PATH, SUBNAM, INFO, INFOE, OPTS, M, N, KL, KU, N5, IMAT, NFAIL, NERRS, NOUT)
ALAERH
Definition: alaerh.f:147
double precision function dget06(RCOND, RCONDC)
DGET06
Definition: dget06.f:56
subroutine dlacpy(UPLO, M, N, A, LDA, B, LDB)
DLACPY
Definition: dlacpy.f:104
subroutine aladhd(IOUNIT, PATH)
ALADHD
Definition: aladhd.f:71
subroutine dsytri2(UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
DSYTRI2
Definition: dsytri2.f:128
subroutine dpot05(UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
DPOT05
Definition: dpot05.f:164
subroutine dlatb4(PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
DLATB4
Definition: dlatb4.f:120
subroutine dsytrf(UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO)
DSYTRF
Definition: dsytrf.f:183
subroutine dlatms(M, N, DIST, ISEED, SYM, D, MODE, COND, DMAX, KL, KU, PACK, A, LDA, WORK, INFO)
DLATMS
Definition: dlatms.f:321
subroutine dsyt01(UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
DSYT01
Definition: dsyt01.f:124
subroutine dsysv(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, LWORK, INFO)
DSYSV computes the solution to system of linear equations A * X = B for SY matrices ...
Definition: dsysv.f:171
subroutine dget04(N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID)
DGET04
Definition: dget04.f:103
subroutine xlaenv(ISPEC, NVALUE)
XLAENV
Definition: xlaenv.f:82
subroutine derrvx(PATH, NUNIT)
DERRVX
Definition: derrvx.f:56
double precision function dlansy(NORM, UPLO, N, A, LDA, WORK)
DLANSY
Definition: dlansy.f:123
subroutine dsysvx(FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB, X, LDX, RCOND, FERR, BERR, WORK, LWORK, IWORK, INFO)
DSYSVX computes the solution to system of linear equations A * X = B for SY matrices ...
Definition: dsysvx.f:283
subroutine ddrvsy(DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
DDRVSY
Definition: ddrvsy.f:152
subroutine dpot02(UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
DPOT02
Definition: dpot02.f:127
subroutine dlarhs(PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO)
DLARHS
Definition: dlarhs.f:204