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