LAPACK  3.6.1
LAPACK: Linear Algebra PACKage
zdrvls.f
Go to the documentation of this file.
1 *> \brief \b ZDRVLS
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 ZDRVLS( DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB,
12 * NBVAL, NXVAL, THRESH, TSTERR, A, COPYA, B,
13 * COPYB, C, S, COPYS, WORK, RWORK, IWORK, NOUT )
14 *
15 * .. Scalar Arguments ..
16 * LOGICAL TSTERR
17 * INTEGER NM, NN, NNB, NNS, NOUT
18 * DOUBLE PRECISION THRESH
19 * ..
20 * .. Array Arguments ..
21 * LOGICAL DOTYPE( * )
22 * INTEGER IWORK( * ), MVAL( * ), NBVAL( * ), NSVAL( * ),
23 * $ NVAL( * ), NXVAL( * )
24 * DOUBLE PRECISION COPYS( * ), RWORK( * ), S( * )
25 * COMPLEX*16 A( * ), B( * ), C( * ), COPYA( * ), COPYB( * ),
26 * $ WORK( * )
27 * ..
28 *
29 *
30 *> \par Purpose:
31 * =============
32 *>
33 *> \verbatim
34 *>
35 *> ZDRVLS tests the least squares driver routines ZGELS, CGELSS, ZGELSY
36 *> and CGELSD.
37 *> \endverbatim
38 *
39 * Arguments:
40 * ==========
41 *
42 *> \param[in] DOTYPE
43 *> \verbatim
44 *> DOTYPE is LOGICAL array, dimension (NTYPES)
45 *> The matrix types to be used for testing. Matrices of type j
46 *> (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
47 *> .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
48 *> The matrix of type j is generated as follows:
49 *> j=1: A = U*D*V where U and V are random unitary matrices
50 *> and D has random entries (> 0.1) taken from a uniform
51 *> distribution (0,1). A is full rank.
52 *> j=2: The same of 1, but A is scaled up.
53 *> j=3: The same of 1, but A is scaled down.
54 *> j=4: A = U*D*V where U and V are random unitary matrices
55 *> and D has 3*min(M,N)/4 random entries (> 0.1) taken
56 *> from a uniform distribution (0,1) and the remaining
57 *> entries set to 0. A is rank-deficient.
58 *> j=5: The same of 4, but A is scaled up.
59 *> j=6: The same of 5, but A is scaled down.
60 *> \endverbatim
61 *>
62 *> \param[in] NM
63 *> \verbatim
64 *> NM is INTEGER
65 *> The number of values of M contained in the vector MVAL.
66 *> \endverbatim
67 *>
68 *> \param[in] MVAL
69 *> \verbatim
70 *> MVAL is INTEGER array, dimension (NM)
71 *> The values of the matrix row dimension M.
72 *> \endverbatim
73 *>
74 *> \param[in] NN
75 *> \verbatim
76 *> NN is INTEGER
77 *> The number of values of N contained in the vector NVAL.
78 *> \endverbatim
79 *>
80 *> \param[in] NVAL
81 *> \verbatim
82 *> NVAL is INTEGER array, dimension (NN)
83 *> The values of the matrix column dimension N.
84 *> \endverbatim
85 *>
86 *> \param[in] NNB
87 *> \verbatim
88 *> NNB is INTEGER
89 *> The number of values of NB and NX contained in the
90 *> vectors NBVAL and NXVAL. The blocking parameters are used
91 *> in pairs (NB,NX).
92 *> \endverbatim
93 *>
94 *> \param[in] NBVAL
95 *> \verbatim
96 *> NBVAL is INTEGER array, dimension (NNB)
97 *> The values of the blocksize NB.
98 *> \endverbatim
99 *>
100 *> \param[in] NXVAL
101 *> \verbatim
102 *> NXVAL is INTEGER array, dimension (NNB)
103 *> The values of the crossover point NX.
104 *> \endverbatim
105 *>
106 *> \param[in] NNS
107 *> \verbatim
108 *> NNS is INTEGER
109 *> The number of values of NRHS contained in the vector NSVAL.
110 *> \endverbatim
111 *>
112 *> \param[in] NSVAL
113 *> \verbatim
114 *> NSVAL is INTEGER array, dimension (NNS)
115 *> The values of the number of right hand sides NRHS.
116 *> \endverbatim
117 *>
118 *> \param[in] THRESH
119 *> \verbatim
120 *> THRESH is DOUBLE PRECISION
121 *> The threshold value for the test ratios. A result is
122 *> included in the output file if RESULT >= THRESH. To have
123 *> every test ratio printed, use THRESH = 0.
124 *> \endverbatim
125 *>
126 *> \param[in] TSTERR
127 *> \verbatim
128 *> TSTERR is LOGICAL
129 *> Flag that indicates whether error exits are to be tested.
130 *> \endverbatim
131 *>
132 *> \param[out] A
133 *> \verbatim
134 *> A is COMPLEX*16 array, dimension (MMAX*NMAX)
135 *> where MMAX is the maximum value of M in MVAL and NMAX is the
136 *> maximum value of N in NVAL.
137 *> \endverbatim
138 *>
139 *> \param[out] COPYA
140 *> \verbatim
141 *> COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)
142 *> \endverbatim
143 *>
144 *> \param[out] B
145 *> \verbatim
146 *> B is COMPLEX*16 array, dimension (MMAX*NSMAX)
147 *> where MMAX is the maximum value of M in MVAL and NSMAX is the
148 *> maximum value of NRHS in NSVAL.
149 *> \endverbatim
150 *>
151 *> \param[out] COPYB
152 *> \verbatim
153 *> COPYB is COMPLEX*16 array, dimension (MMAX*NSMAX)
154 *> \endverbatim
155 *>
156 *> \param[out] C
157 *> \verbatim
158 *> C is COMPLEX*16 array, dimension (MMAX*NSMAX)
159 *> \endverbatim
160 *>
161 *> \param[out] S
162 *> \verbatim
163 *> S is DOUBLE PRECISION array, dimension
164 *> (min(MMAX,NMAX))
165 *> \endverbatim
166 *>
167 *> \param[out] COPYS
168 *> \verbatim
169 *> COPYS is DOUBLE PRECISION array, dimension
170 *> (min(MMAX,NMAX))
171 *> \endverbatim
172 *>
173 *> \param[out] WORK
174 *> \verbatim
175 *> WORK is COMPLEX*16 array, dimension
176 *> (MMAX*NMAX + 4*NMAX + MMAX).
177 *> \endverbatim
178 *>
179 *> \param[out] RWORK
180 *> \verbatim
181 *> RWORK is DOUBLE PRECISION array, dimension (5*NMAX-1)
182 *> \endverbatim
183 *>
184 *> \param[out] IWORK
185 *> \verbatim
186 *> IWORK is INTEGER array, dimension (15*NMAX)
187 *> \endverbatim
188 *>
189 *> \param[in] NOUT
190 *> \verbatim
191 *> NOUT is INTEGER
192 *> The unit number for output.
193 *> \endverbatim
194 *
195 * Authors:
196 * ========
197 *
198 *> \author Univ. of Tennessee
199 *> \author Univ. of California Berkeley
200 *> \author Univ. of Colorado Denver
201 *> \author NAG Ltd.
202 *
203 *> \date November 2015
204 *
205 *> \ingroup complex16_lin
206 *
207 * =====================================================================
208  SUBROUTINE zdrvls( DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB,
209  $ nbval, nxval, thresh, tsterr, a, copya, b,
210  $ copyb, c, s, copys, work, rwork, iwork, nout )
211 *
212 * -- LAPACK test routine (version 3.6.0) --
213 * -- LAPACK is a software package provided by Univ. of Tennessee, --
214 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
215 * November 2015
216 *
217 * .. Scalar Arguments ..
218  LOGICAL TSTERR
219  INTEGER NM, NN, NNB, NNS, NOUT
220  DOUBLE PRECISION THRESH
221 * ..
222 * .. Array Arguments ..
223  LOGICAL DOTYPE( * )
224  INTEGER IWORK( * ), MVAL( * ), NBVAL( * ), NSVAL( * ),
225  $ nval( * ), nxval( * )
226  DOUBLE PRECISION COPYS( * ), RWORK( * ), S( * )
227  COMPLEX*16 A( * ), B( * ), C( * ), COPYA( * ), COPYB( * ),
228  $ work( * )
229 * ..
230 *
231 * =====================================================================
232 *
233 * .. Parameters ..
234  INTEGER NTESTS
235  parameter ( ntests = 14 )
236  INTEGER SMLSIZ
237  parameter ( smlsiz = 25 )
238  DOUBLE PRECISION ONE, ZERO
239  parameter ( one = 1.0d+0, zero = 0.0d+0 )
240  COMPLEX*16 CONE, CZERO
241  parameter ( cone = ( 1.0d+0, 0.0d+0 ),
242  $ czero = ( 0.0d+0, 0.0d+0 ) )
243 * ..
244 * .. Local Scalars ..
245  CHARACTER TRANS
246  CHARACTER*3 PATH
247  INTEGER CRANK, I, IM, IN, INB, INFO, INS, IRANK,
248  $ iscale, itran, itype, j, k, lda, ldb, ldwork,
249  $ lwlsy, lwork, m, mnmin, n, nb, ncols, nerrs,
250  $ nfail, nrhs, nrows, nrun, rank
251  DOUBLE PRECISION EPS, NORMA, NORMB, RCOND
252 * ..
253 * .. Local Arrays ..
254  INTEGER ISEED( 4 ), ISEEDY( 4 )
255  DOUBLE PRECISION RESULT( ntests )
256 * ..
257 * .. External Functions ..
258  DOUBLE PRECISION DASUM, DLAMCH, ZQRT12, ZQRT14, ZQRT17
259  EXTERNAL dasum, dlamch, zqrt12, zqrt14, zqrt17
260 * ..
261 * .. External Subroutines ..
262  EXTERNAL alaerh, alahd, alasvm, daxpy, dlasrt, xlaenv,
263  $ zdscal, zerrls, zgels, zgelsd, zgelss,
264  $ zgelsy, zgemm, zlacpy, zlarnv, zqrt13, zqrt15,
265  $ zqrt16
266 * ..
267 * .. Intrinsic Functions ..
268  INTRINSIC dble, max, min, sqrt
269 * ..
270 * .. Scalars in Common ..
271  LOGICAL LERR, OK
272  CHARACTER*32 SRNAMT
273  INTEGER INFOT, IOUNIT
274 * ..
275 * .. Common blocks ..
276  COMMON / infoc / infot, iounit, ok, lerr
277  COMMON / srnamc / srnamt
278 * ..
279 * .. Data statements ..
280  DATA iseedy / 1988, 1989, 1990, 1991 /
281 * ..
282 * .. Executable Statements ..
283 *
284 * Initialize constants and the random number seed.
285 *
286  path( 1: 1 ) = 'Zomplex precision'
287  path( 2: 3 ) = 'LS'
288  nrun = 0
289  nfail = 0
290  nerrs = 0
291  DO 10 i = 1, 4
292  iseed( i ) = iseedy( i )
293  10 CONTINUE
294  eps = dlamch( 'Epsilon' )
295 *
296 * Threshold for rank estimation
297 *
298  rcond = sqrt( eps ) - ( sqrt( eps )-eps ) / 2
299 *
300 * Test the error exits
301 *
302  CALL xlaenv( 9, smlsiz )
303  IF( tsterr )
304  $ CALL zerrls( path, nout )
305 *
306 * Print the header if NM = 0 or NN = 0 and THRESH = 0.
307 *
308  IF( ( nm.EQ.0 .OR. nn.EQ.0 ) .AND. thresh.EQ.zero )
309  $ CALL alahd( nout, path )
310  infot = 0
311 *
312  DO 140 im = 1, nm
313  m = mval( im )
314  lda = max( 1, m )
315 *
316  DO 130 in = 1, nn
317  n = nval( in )
318  mnmin = min( m, n )
319  ldb = max( 1, m, n )
320 *
321  DO 120 ins = 1, nns
322  nrhs = nsval( ins )
323  lwork = max( 1, ( m+nrhs )*( n+2 ), ( n+nrhs )*( m+2 ),
324  $ m*n+4*mnmin+max( m, n ), 2*n+m )
325 *
326  DO 110 irank = 1, 2
327  DO 100 iscale = 1, 3
328  itype = ( irank-1 )*3 + iscale
329  IF( .NOT.dotype( itype ) )
330  $ GO TO 100
331 *
332  IF( irank.EQ.1 ) THEN
333 *
334 * Test ZGELS
335 *
336 * Generate a matrix of scaling type ISCALE
337 *
338  CALL zqrt13( iscale, m, n, copya, lda, norma,
339  $ iseed )
340  DO 40 inb = 1, nnb
341  nb = nbval( inb )
342  CALL xlaenv( 1, nb )
343  CALL xlaenv( 3, nxval( inb ) )
344 *
345  DO 30 itran = 1, 2
346  IF( itran.EQ.1 ) THEN
347  trans = 'N'
348  nrows = m
349  ncols = n
350  ELSE
351  trans = 'C'
352  nrows = n
353  ncols = m
354  END IF
355  ldwork = max( 1, ncols )
356 *
357 * Set up a consistent rhs
358 *
359  IF( ncols.GT.0 ) THEN
360  CALL zlarnv( 2, iseed, ncols*nrhs,
361  $ work )
362  CALL zdscal( ncols*nrhs,
363  $ one / dble( ncols ), work,
364  $ 1 )
365  END IF
366  CALL zgemm( trans, 'No transpose', nrows,
367  $ nrhs, ncols, cone, copya, lda,
368  $ work, ldwork, czero, b, ldb )
369  CALL zlacpy( 'Full', nrows, nrhs, b, ldb,
370  $ copyb, ldb )
371 *
372 * Solve LS or overdetermined system
373 *
374  IF( m.GT.0 .AND. n.GT.0 ) THEN
375  CALL zlacpy( 'Full', m, n, copya, lda,
376  $ a, lda )
377  CALL zlacpy( 'Full', nrows, nrhs,
378  $ copyb, ldb, b, ldb )
379  END IF
380  srnamt = 'ZGELS '
381  CALL zgels( trans, m, n, nrhs, a, lda, b,
382  $ ldb, work, lwork, info )
383 *
384  IF( info.NE.0 )
385  $ CALL alaerh( path, 'ZGELS ', info, 0,
386  $ trans, m, n, nrhs, -1, nb,
387  $ itype, nfail, nerrs,
388  $ nout )
389 *
390 * Check correctness of results
391 *
392  ldwork = max( 1, nrows )
393  IF( nrows.GT.0 .AND. nrhs.GT.0 )
394  $ CALL zlacpy( 'Full', nrows, nrhs,
395  $ copyb, ldb, c, ldb )
396  CALL zqrt16( trans, m, n, nrhs, copya,
397  $ lda, b, ldb, c, ldb, rwork,
398  $ result( 1 ) )
399 *
400  IF( ( itran.EQ.1 .AND. m.GE.n ) .OR.
401  $ ( itran.EQ.2 .AND. m.LT.n ) ) THEN
402 *
403 * Solving LS system
404 *
405  result( 2 ) = zqrt17( trans, 1, m, n,
406  $ nrhs, copya, lda, b, ldb,
407  $ copyb, ldb, c, work,
408  $ lwork )
409  ELSE
410 *
411 * Solving overdetermined system
412 *
413  result( 2 ) = zqrt14( trans, m, n,
414  $ nrhs, copya, lda, b, ldb,
415  $ work, lwork )
416  END IF
417 *
418 * Print information about the tests that
419 * did not pass the threshold.
420 *
421  DO 20 k = 1, 2
422  IF( result( k ).GE.thresh ) THEN
423  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
424  $ CALL alahd( nout, path )
425  WRITE( nout, fmt = 9999 )trans, m,
426  $ n, nrhs, nb, itype, k,
427  $ result( k )
428  nfail = nfail + 1
429  END IF
430  20 CONTINUE
431  nrun = nrun + 2
432  30 CONTINUE
433  40 CONTINUE
434  END IF
435 *
436 * Generate a matrix of scaling type ISCALE and rank
437 * type IRANK.
438 *
439  CALL zqrt15( iscale, irank, m, n, nrhs, copya, lda,
440  $ copyb, ldb, copys, rank, norma, normb,
441  $ iseed, work, lwork )
442 *
443 * workspace used: MAX(M+MIN(M,N),NRHS*MIN(M,N),2*N+M)
444 *
445  ldwork = max( 1, m )
446 *
447 * Loop for testing different block sizes.
448 *
449  DO 90 inb = 1, nnb
450  nb = nbval( inb )
451  CALL xlaenv( 1, nb )
452  CALL xlaenv( 3, nxval( inb ) )
453 *
454 * Test ZGELSY
455 *
456 * ZGELSY: Compute the minimum-norm solution
457 * X to min( norm( A * X - B ) )
458 * using the rank-revealing orthogonal
459 * factorization.
460 *
461  CALL zlacpy( 'Full', m, n, copya, lda, a, lda )
462  CALL zlacpy( 'Full', m, nrhs, copyb, ldb, b,
463  $ ldb )
464 *
465 * Initialize vector IWORK.
466 *
467  DO 70 j = 1, n
468  iwork( j ) = 0
469  70 CONTINUE
470 *
471 * Set LWLSY to the adequate value.
472 *
473  lwlsy = mnmin + max( 2*mnmin, nb*( n+1 ),
474  $ mnmin+nb*nrhs )
475  lwlsy = max( 1, lwlsy )
476 *
477  srnamt = 'ZGELSY'
478  CALL zgelsy( m, n, nrhs, a, lda, b, ldb, iwork,
479  $ rcond, crank, work, lwlsy, rwork,
480  $ info )
481  IF( info.NE.0 )
482  $ CALL alaerh( path, 'ZGELSY', info, 0, ' ', m,
483  $ n, nrhs, -1, nb, itype, nfail,
484  $ nerrs, nout )
485 *
486 * workspace used: 2*MNMIN+NB*NB+NB*MAX(N,NRHS)
487 *
488 * Test 3: Compute relative error in svd
489 * workspace: M*N + 4*MIN(M,N) + MAX(M,N)
490 *
491  result( 3 ) = zqrt12( crank, crank, a, lda,
492  $ copys, work, lwork, rwork )
493 *
494 * Test 4: Compute error in solution
495 * workspace: M*NRHS + M
496 *
497  CALL zlacpy( 'Full', m, nrhs, copyb, ldb, work,
498  $ ldwork )
499  CALL zqrt16( 'No transpose', m, n, nrhs, copya,
500  $ lda, b, ldb, work, ldwork, rwork,
501  $ result( 4 ) )
502 *
503 * Test 5: Check norm of r'*A
504 * workspace: NRHS*(M+N)
505 *
506  result( 5 ) = zero
507  IF( m.GT.crank )
508  $ result( 5 ) = zqrt17( 'No transpose', 1, m,
509  $ n, nrhs, copya, lda, b, ldb,
510  $ copyb, ldb, c, work, lwork )
511 *
512 * Test 6: Check if x is in the rowspace of A
513 * workspace: (M+NRHS)*(N+2)
514 *
515  result( 6 ) = zero
516 *
517  IF( n.GT.crank )
518  $ result( 6 ) = zqrt14( 'No transpose', m, n,
519  $ nrhs, copya, lda, b, ldb,
520  $ work, lwork )
521 *
522 * Test ZGELSS
523 *
524 * ZGELSS: Compute the minimum-norm solution
525 * X to min( norm( A * X - B ) )
526 * using the SVD.
527 *
528  CALL zlacpy( 'Full', m, n, copya, lda, a, lda )
529  CALL zlacpy( 'Full', m, nrhs, copyb, ldb, b,
530  $ ldb )
531  srnamt = 'ZGELSS'
532  CALL zgelss( m, n, nrhs, a, lda, b, ldb, s,
533  $ rcond, crank, work, lwork, rwork,
534  $ info )
535 *
536  IF( info.NE.0 )
537  $ CALL alaerh( path, 'ZGELSS', info, 0, ' ', m,
538  $ n, nrhs, -1, nb, itype, nfail,
539  $ nerrs, nout )
540 *
541 * workspace used: 3*min(m,n) +
542 * max(2*min(m,n),nrhs,max(m,n))
543 *
544 * Test 7: Compute relative error in svd
545 *
546  IF( rank.GT.0 ) THEN
547  CALL daxpy( mnmin, -one, copys, 1, s, 1 )
548  result( 7 ) = dasum( mnmin, s, 1 ) /
549  $ dasum( mnmin, copys, 1 ) /
550  $ ( eps*dble( mnmin ) )
551  ELSE
552  result( 7 ) = zero
553  END IF
554 *
555 * Test 8: Compute error in solution
556 *
557  CALL zlacpy( 'Full', m, nrhs, copyb, ldb, work,
558  $ ldwork )
559  CALL zqrt16( 'No transpose', m, n, nrhs, copya,
560  $ lda, b, ldb, work, ldwork, rwork,
561  $ result( 8 ) )
562 *
563 * Test 9: Check norm of r'*A
564 *
565  result( 9 ) = zero
566  IF( m.GT.crank )
567  $ result( 9 ) = zqrt17( 'No transpose', 1, m,
568  $ n, nrhs, copya, lda, b, ldb,
569  $ copyb, ldb, c, work, lwork )
570 *
571 * Test 10: Check if x is in the rowspace of A
572 *
573  result( 10 ) = zero
574  IF( n.GT.crank )
575  $ result( 10 ) = zqrt14( 'No transpose', m, n,
576  $ nrhs, copya, lda, b, ldb,
577  $ work, lwork )
578 *
579 * Test ZGELSD
580 *
581 * ZGELSD: Compute the minimum-norm solution X
582 * to min( norm( A * X - B ) ) using a
583 * divide and conquer SVD.
584 *
585  CALL xlaenv( 9, 25 )
586 *
587  CALL zlacpy( 'Full', m, n, copya, lda, a, lda )
588  CALL zlacpy( 'Full', m, nrhs, copyb, ldb, b,
589  $ ldb )
590 *
591  srnamt = 'ZGELSD'
592  CALL zgelsd( m, n, nrhs, a, lda, b, ldb, s,
593  $ rcond, crank, work, lwork, rwork,
594  $ iwork, info )
595  IF( info.NE.0 )
596  $ CALL alaerh( path, 'ZGELSD', info, 0, ' ', m,
597  $ n, nrhs, -1, nb, itype, nfail,
598  $ nerrs, nout )
599 *
600 * Test 11: Compute relative error in svd
601 *
602  IF( rank.GT.0 ) THEN
603  CALL daxpy( mnmin, -one, copys, 1, s, 1 )
604  result( 11 ) = dasum( mnmin, s, 1 ) /
605  $ dasum( mnmin, copys, 1 ) /
606  $ ( eps*dble( mnmin ) )
607  ELSE
608  result( 11 ) = zero
609  END IF
610 *
611 * Test 12: Compute error in solution
612 *
613  CALL zlacpy( 'Full', m, nrhs, copyb, ldb, work,
614  $ ldwork )
615  CALL zqrt16( 'No transpose', m, n, nrhs, copya,
616  $ lda, b, ldb, work, ldwork, rwork,
617  $ result( 12 ) )
618 *
619 * Test 13: Check norm of r'*A
620 *
621  result( 13 ) = zero
622  IF( m.GT.crank )
623  $ result( 13 ) = zqrt17( 'No transpose', 1, m,
624  $ n, nrhs, copya, lda, b, ldb,
625  $ copyb, ldb, c, work, lwork )
626 *
627 * Test 14: Check if x is in the rowspace of A
628 *
629  result( 14 ) = zero
630  IF( n.GT.crank )
631  $ result( 14 ) = zqrt14( 'No transpose', m, n,
632  $ nrhs, copya, lda, b, ldb,
633  $ work, lwork )
634 *
635 * Print information about the tests that did not
636 * pass the threshold.
637 *
638  DO 80 k = 3, ntests
639  IF( result( k ).GE.thresh ) THEN
640  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
641  $ CALL alahd( nout, path )
642  WRITE( nout, fmt = 9998 )m, n, nrhs, nb,
643  $ itype, k, result( k )
644  nfail = nfail + 1
645  END IF
646  80 CONTINUE
647  nrun = nrun + 12
648 *
649  90 CONTINUE
650  100 CONTINUE
651  110 CONTINUE
652  120 CONTINUE
653  130 CONTINUE
654  140 CONTINUE
655 *
656 * Print a summary of the results.
657 *
658  CALL alasvm( path, nout, nfail, nrun, nerrs )
659 *
660  9999 FORMAT( ' TRANS=''', a1, ''', M=', i5, ', N=', i5, ', NRHS=', i4,
661  $ ', NB=', i4, ', type', i2, ', test(', i2, ')=', g12.5 )
662  9998 FORMAT( ' M=', i5, ', N=', i5, ', NRHS=', i4, ', NB=', i4,
663  $ ', type', i2, ', test(', i2, ')=', g12.5 )
664  RETURN
665 *
666 * End of ZDRVLS
667 *
668  END
alasvm
subroutine alasvm(TYPE, NOUT, NFAIL, NRUN, NERRS)
ALASVM
Definition: alasvm.f:75
dlasrt
subroutine dlasrt(ID, N, D, INFO)
DLASRT sorts numbers in increasing or decreasing order.
Definition: dlasrt.f:90
alahd
subroutine alahd(IOUNIT, PATH)
ALAHD
Definition: alahd.f:95
zqrt16
subroutine zqrt16(TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZQRT16
Definition: zqrt16.f:135
zgels
subroutine zgels(TRANS, M, N, NRHS, A, LDA, B, LDB, WORK, LWORK, INFO)
ZGELS solves overdetermined or underdetermined systems for GE matrices
Definition: zgels.f:184
alaerh
subroutine alaerh(PATH, SUBNAM, INFO, INFOE, OPTS, M, N, KL, KU, N5, IMAT, NFAIL, NERRS, NOUT)
ALAERH
Definition: alaerh.f:149
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:105
zlarnv
subroutine zlarnv(IDIST, ISEED, N, X)
ZLARNV returns a vector of random numbers from a uniform or normal distribution.
Definition: zlarnv.f:101
zgelsy
subroutine zgelsy(M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK, WORK, LWORK, RWORK, INFO)
ZGELSY solves overdetermined or underdetermined systems for GE matrices
Definition: zgelsy.f:212
zgelss
subroutine zgelss(M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, WORK, LWORK, RWORK, INFO)
ZGELSS solves overdetermined or underdetermined systems for GE matrices
Definition: zgelss.f:180
zgelsd
subroutine zgelsd(M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, WORK, LWORK, RWORK, IWORK, INFO)
ZGELSD computes the minimum-norm solution to a linear least squares problem for GE matrices ...
Definition: zgelsd.f:227
zgemm
subroutine zgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
ZGEMM
Definition: zgemm.f:189
daxpy
subroutine daxpy(N, DA, DX, INCX, DY, INCY)
DAXPY
Definition: daxpy.f:54
xlaenv
subroutine xlaenv(ISPEC, NVALUE)
XLAENV
Definition: xlaenv.f:83
zdrvls
subroutine zdrvls(DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB, NBVAL, NXVAL, THRESH, TSTERR, A, COPYA, B, COPYB, C, S, COPYS, WORK, RWORK, IWORK, NOUT)
ZDRVLS
Definition: zdrvls.f:211
zqrt13
subroutine zqrt13(SCALE, M, N, A, LDA, NORMA, ISEED)
ZQRT13
Definition: zqrt13.f:93
zerrls
subroutine zerrls(PATH, NUNIT)
ZERRLS
Definition: zerrls.f:57
zdscal
subroutine zdscal(N, DA, ZX, INCX)
ZDSCAL
Definition: zdscal.f:54
zqrt15
subroutine zqrt15(SCALE, RKSEL, M, N, NRHS, A, LDA, B, LDB, S, RANK, NORMA, NORMB, ISEED, WORK, LWORK)
ZQRT15
Definition: zqrt15.f:151