LAPACK  3.5.0
LAPACK: Linear Algebra PACKage
cdrvls.f File Reference

Go to the source code of this file.

Functions/Subroutines

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 More...
 

Function/Subroutine Documentation

subroutine cdrvls ( logical, dimension( * )  DOTYPE,
integer  NM,
integer, dimension( * )  MVAL,
integer  NN,
integer, dimension( * )  NVAL,
integer  NNS,
integer, dimension( * )  NSVAL,
integer  NNB,
integer, dimension( * )  NBVAL,
integer, dimension( * )  NXVAL,
real  THRESH,
logical  TSTERR,
complex, dimension( * )  A,
complex, dimension( * )  COPYA,
complex, dimension( * )  B,
complex, dimension( * )  COPYB,
complex, dimension( * )  C,
real, dimension( * )  S,
real, dimension( * )  COPYS,
complex, dimension( * )  WORK,
real, dimension( * )  RWORK,
integer, dimension( * )  IWORK,
integer  NOUT 
)

CDRVLS

Purpose:
 CDRVLS tests the least squares driver routines CGELS, CGELSX, CGELSS,
 CGELSY and CGELSD.
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.
          The matrix of type j is generated as follows:
          j=1: A = U*D*V where U and V are random unitary matrices
               and D has random entries (> 0.1) taken from a uniform
               distribution (0,1). A is full rank.
          j=2: The same of 1, but A is scaled up.
          j=3: The same of 1, but A is scaled down.
          j=4: A = U*D*V where U and V are random unitary matrices
               and D has 3*min(M,N)/4 random entries (> 0.1) taken
               from a uniform distribution (0,1) and the remaining
               entries set to 0. A is rank-deficient.
          j=5: The same of 4, but A is scaled up.
          j=6: The same of 5, but A is scaled down.
[in]NM
          NM is INTEGER
          The number of values of M contained in the vector MVAL.
[in]MVAL
          MVAL is INTEGER array, dimension (NM)
          The values of the matrix row dimension M.
[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 column dimension N.
[in]NNB
          NNB is INTEGER
          The number of values of NB and NX contained in the
          vectors NBVAL and NXVAL.  The blocking parameters are used
          in pairs (NB,NX).
[in]NBVAL
          NBVAL is INTEGER array, dimension (NNB)
          The values of the blocksize NB.
[in]NXVAL
          NXVAL is INTEGER array, dimension (NNB)
          The values of the crossover point NX.
[in]NNS
          NNS is INTEGER
          The number of values of NRHS contained in the vector NSVAL.
[in]NSVAL
          NSVAL is INTEGER array, dimension (NNS)
          The values of the number of right hand sides NRHS.
[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.
[out]A
          A is COMPLEX array, dimension (MMAX*NMAX)
          where MMAX is the maximum value of M in MVAL and NMAX is the
          maximum value of N in NVAL.
[out]COPYA
          COPYA is COMPLEX array, dimension (MMAX*NMAX)
[out]B
          B is COMPLEX array, dimension (MMAX*NSMAX)
          where MMAX is the maximum value of M in MVAL and NSMAX is the
          maximum value of NRHS in NSVAL.
[out]COPYB
          COPYB is COMPLEX array, dimension (MMAX*NSMAX)
[out]C
          C is COMPLEX array, dimension (MMAX*NSMAX)
[out]S
          S is REAL array, dimension
                      (min(MMAX,NMAX))
[out]COPYS
          COPYS is REAL array, dimension
                      (min(MMAX,NMAX))
[out]WORK
          WORK is COMPLEX array, dimension
                      (MMAX*NMAX + 4*NMAX + MMAX).
[out]RWORK
          RWORK is REAL array, dimension (5*NMAX-1)
[out]IWORK
          IWORK is INTEGER array, dimension (15*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.
Date
November 2011

Definition at line 213 of file cdrvls.f.

213 *
214 * -- LAPACK test routine (version 3.4.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 2011
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 = 18 )
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,
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  DO 50 j = 1, n
448  iwork( j ) = 0
449  50 CONTINUE
450  ldwork = max( 1, m )
451 *
452 * Test CGELSX
453 *
454 * CGELSX: Compute the minimum-norm solution X
455 * to min( norm( A * X - B ) )
456 * using a complete orthogonal factorization.
457 *
458  CALL clacpy( 'Full', m, n, copya, lda, a, lda )
459  CALL clacpy( 'Full', m, nrhs, copyb, ldb, b, ldb )
460 *
461  srnamt = 'CGELSX'
462  CALL cgelsx( m, n, nrhs, a, lda, b, ldb, iwork,
463  $ rcond, crank, work, rwork, info )
464 *
465  IF( info.NE.0 )
466  $ CALL alaerh( path, 'CGELSX', info, 0, ' ', m, n,
467  $ nrhs, -1, nb, itype, nfail, nerrs,
468  $ nout )
469 *
470 * workspace used: MAX( MNMIN+3*N, 2*MNMIN+NRHS )
471 *
472 * Test 3: Compute relative error in svd
473 * workspace: M*N + 4*MIN(M,N) + MAX(M,N)
474 *
475  result( 3 ) = cqrt12( crank, crank, a, lda, copys,
476  $ work, lwork, rwork )
477 *
478 * Test 4: Compute error in solution
479 * workspace: M*NRHS + M
480 *
481  CALL clacpy( 'Full', m, nrhs, copyb, ldb, work,
482  $ ldwork )
483  CALL cqrt16( 'No transpose', m, n, nrhs, copya,
484  $ lda, b, ldb, work, ldwork, rwork,
485  $ result( 4 ) )
486 *
487 * Test 5: Check norm of r'*A
488 * workspace: NRHS*(M+N)
489 *
490  result( 5 ) = zero
491  IF( m.GT.crank )
492  $ result( 5 ) = cqrt17( 'No transpose', 1, m, n,
493  $ nrhs, copya, lda, b, ldb, copyb,
494  $ ldb, c, work, lwork )
495 *
496 * Test 6: Check if x is in the rowspace of A
497 * workspace: (M+NRHS)*(N+2)
498 *
499  result( 6 ) = zero
500 *
501  IF( n.GT.crank )
502  $ result( 6 ) = cqrt14( 'No transpose', m, n,
503  $ nrhs, copya, lda, b, ldb, work,
504  $ lwork )
505 *
506 * Print information about the tests that did not
507 * pass the threshold.
508 *
509  DO 60 k = 3, 6
510  IF( result( k ).GE.thresh ) THEN
511  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
512  $ CALL alahd( nout, path )
513  WRITE( nout, fmt = 9998 )m, n, nrhs, 0,
514  $ itype, k, result( k )
515  nfail = nfail + 1
516  END IF
517  60 CONTINUE
518  nrun = nrun + 4
519 *
520 * Loop for testing different block sizes.
521 *
522  DO 90 inb = 1, nnb
523  nb = nbval( inb )
524  CALL xlaenv( 1, nb )
525  CALL xlaenv( 3, nxval( inb ) )
526 *
527 * Test CGELSY
528 *
529 * CGELSY: Compute the minimum-norm solution
530 * X to min( norm( A * X - B ) )
531 * using the rank-revealing orthogonal
532 * factorization.
533 *
534  CALL clacpy( 'Full', m, n, copya, lda, a, lda )
535  CALL clacpy( 'Full', m, nrhs, copyb, ldb, b,
536  $ ldb )
537 *
538 * Initialize vector IWORK.
539 *
540  DO 70 j = 1, n
541  iwork( j ) = 0
542  70 CONTINUE
543 *
544 * Set LWLSY to the adequate value.
545 *
546  lwlsy = mnmin + max( 2*mnmin, nb*( n+1 ),
547  $ mnmin+nb*nrhs )
548  lwlsy = max( 1, lwlsy )
549 *
550  srnamt = 'CGELSY'
551  CALL cgelsy( m, n, nrhs, a, lda, b, ldb, iwork,
552  $ rcond, crank, work, lwlsy, rwork,
553  $ info )
554  IF( info.NE.0 )
555  $ CALL alaerh( path, 'CGELSY', info, 0, ' ', m,
556  $ n, nrhs, -1, nb, itype, nfail,
557  $ nerrs, nout )
558 *
559 * workspace used: 2*MNMIN+NB*NB+NB*MAX(N,NRHS)
560 *
561 * Test 7: Compute relative error in svd
562 * workspace: M*N + 4*MIN(M,N) + MAX(M,N)
563 *
564  result( 7 ) = cqrt12( crank, crank, a, lda,
565  $ copys, work, lwork, rwork )
566 *
567 * Test 8: Compute error in solution
568 * workspace: M*NRHS + M
569 *
570  CALL clacpy( 'Full', m, nrhs, copyb, ldb, work,
571  $ ldwork )
572  CALL cqrt16( 'No transpose', m, n, nrhs, copya,
573  $ lda, b, ldb, work, ldwork, rwork,
574  $ result( 8 ) )
575 *
576 * Test 9: Check norm of r'*A
577 * workspace: NRHS*(M+N)
578 *
579  result( 9 ) = zero
580  IF( m.GT.crank )
581  $ result( 9 ) = cqrt17( 'No transpose', 1, m,
582  $ n, nrhs, copya, lda, b, ldb,
583  $ copyb, ldb, c, work, lwork )
584 *
585 * Test 10: Check if x is in the rowspace of A
586 * workspace: (M+NRHS)*(N+2)
587 *
588  result( 10 ) = zero
589 *
590  IF( n.GT.crank )
591  $ result( 10 ) = cqrt14( 'No transpose', m, n,
592  $ nrhs, copya, lda, b, ldb,
593  $ work, lwork )
594 *
595 * Test CGELSS
596 *
597 * CGELSS: Compute the minimum-norm solution
598 * X to min( norm( A * X - B ) )
599 * using the SVD.
600 *
601  CALL clacpy( 'Full', m, n, copya, lda, a, lda )
602  CALL clacpy( 'Full', m, nrhs, copyb, ldb, b,
603  $ ldb )
604  srnamt = 'CGELSS'
605  CALL cgelss( m, n, nrhs, a, lda, b, ldb, s,
606  $ rcond, crank, work, lwork, rwork,
607  $ info )
608 *
609  IF( info.NE.0 )
610  $ CALL alaerh( path, 'CGELSS', info, 0, ' ', m,
611  $ n, nrhs, -1, nb, itype, nfail,
612  $ nerrs, nout )
613 *
614 * workspace used: 3*min(m,n) +
615 * max(2*min(m,n),nrhs,max(m,n))
616 *
617 * Test 11: Compute relative error in svd
618 *
619  IF( rank.GT.0 ) THEN
620  CALL saxpy( mnmin, -one, copys, 1, s, 1 )
621  result( 11 ) = sasum( mnmin, s, 1 ) /
622  $ sasum( mnmin, copys, 1 ) /
623  $ ( eps*REAL( MNMIN ) )
624  ELSE
625  result( 11 ) = zero
626  END IF
627 *
628 * Test 12: Compute error in solution
629 *
630  CALL clacpy( 'Full', m, nrhs, copyb, ldb, work,
631  $ ldwork )
632  CALL cqrt16( 'No transpose', m, n, nrhs, copya,
633  $ lda, b, ldb, work, ldwork, rwork,
634  $ result( 12 ) )
635 *
636 * Test 13: Check norm of r'*A
637 *
638  result( 13 ) = zero
639  IF( m.GT.crank )
640  $ result( 13 ) = cqrt17( 'No transpose', 1, m,
641  $ n, nrhs, copya, lda, b, ldb,
642  $ copyb, ldb, c, work, lwork )
643 *
644 * Test 14: Check if x is in the rowspace of A
645 *
646  result( 14 ) = zero
647  IF( n.GT.crank )
648  $ result( 14 ) = cqrt14( 'No transpose', m, n,
649  $ nrhs, copya, lda, b, ldb,
650  $ work, lwork )
651 *
652 * Test CGELSD
653 *
654 * CGELSD: Compute the minimum-norm solution X
655 * to min( norm( A * X - B ) ) using a
656 * divide and conquer SVD.
657 *
658  CALL xlaenv( 9, 25 )
659 *
660  CALL clacpy( 'Full', m, n, copya, lda, a, lda )
661  CALL clacpy( 'Full', m, nrhs, copyb, ldb, b,
662  $ ldb )
663 *
664  srnamt = 'CGELSD'
665  CALL cgelsd( m, n, nrhs, a, lda, b, ldb, s,
666  $ rcond, crank, work, lwork, rwork,
667  $ iwork, info )
668  IF( info.NE.0 )
669  $ CALL alaerh( path, 'CGELSD', info, 0, ' ', m,
670  $ n, nrhs, -1, nb, itype, nfail,
671  $ nerrs, nout )
672 *
673 * Test 15: Compute relative error in svd
674 *
675  IF( rank.GT.0 ) THEN
676  CALL saxpy( mnmin, -one, copys, 1, s, 1 )
677  result( 15 ) = sasum( mnmin, s, 1 ) /
678  $ sasum( mnmin, copys, 1 ) /
679  $ ( eps*REAL( MNMIN ) )
680  ELSE
681  result( 15 ) = zero
682  END IF
683 *
684 * Test 16: Compute error in solution
685 *
686  CALL clacpy( 'Full', m, nrhs, copyb, ldb, work,
687  $ ldwork )
688  CALL cqrt16( 'No transpose', m, n, nrhs, copya,
689  $ lda, b, ldb, work, ldwork, rwork,
690  $ result( 16 ) )
691 *
692 * Test 17: Check norm of r'*A
693 *
694  result( 17 ) = zero
695  IF( m.GT.crank )
696  $ result( 17 ) = cqrt17( 'No transpose', 1, m,
697  $ n, nrhs, copya, lda, b, ldb,
698  $ copyb, ldb, c, work, lwork )
699 *
700 * Test 18: Check if x is in the rowspace of A
701 *
702  result( 18 ) = zero
703  IF( n.GT.crank )
704  $ result( 18 ) = cqrt14( 'No transpose', m, n,
705  $ nrhs, copya, lda, b, ldb,
706  $ work, lwork )
707 *
708 * Print information about the tests that did not
709 * pass the threshold.
710 *
711  DO 80 k = 7, ntests
712  IF( result( k ).GE.thresh ) THEN
713  IF( nfail.EQ.0 .AND. nerrs.EQ.0 )
714  $ CALL alahd( nout, path )
715  WRITE( nout, fmt = 9998 )m, n, nrhs, nb,
716  $ itype, k, result( k )
717  nfail = nfail + 1
718  END IF
719  80 CONTINUE
720  nrun = nrun + 12
721 *
722  90 CONTINUE
723  100 CONTINUE
724  110 CONTINUE
725  120 CONTINUE
726  130 CONTINUE
727  140 CONTINUE
728 *
729 * Print a summary of the results.
730 *
731  CALL alasvm( path, nout, nfail, nrun, nerrs )
732 *
733  9999 FORMAT( ' TRANS=''', a1, ''', M=', i5, ', N=', i5, ', NRHS=', i4,
734  $ ', NB=', i4, ', type', i2, ', test(', i2, ')=', g12.5 )
735  9998 FORMAT( ' M=', i5, ', N=', i5, ', NRHS=', i4, ', NB=', i4,
736  $ ', type', i2, ', test(', i2, ')=', g12.5 )
737  RETURN
738 *
739 * End of CDRVLS
740 *
subroutine alahd(IOUNIT, PATH)
ALAHD
Definition: alahd.f:95
real function cqrt14(TRANS, M, N, NRHS, A, LDA, X, LDX, WORK, LWORK)
CQRT14
Definition: cqrt14.f:118
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
subroutine alasvm(TYPE, NOUT, NFAIL, NRUN, NERRS)
ALASVM
Definition: alasvm.f:75
real function sasum(N, SX, INCX)
SASUM
Definition: sasum.f:54
real function cqrt12(M, N, A, LDA, S, WORK, LWORK, RWORK)
CQRT12
Definition: cqrt12.f:99
subroutine cqrt13(SCALE, M, N, A, LDA, NORMA, ISEED)
CQRT13
Definition: cqrt13.f:93
subroutine alaerh(PATH, SUBNAM, INFO, INFOE, OPTS, M, N, KL, KU, N5, IMAT, NFAIL, NERRS, NOUT)
ALAERH
Definition: alaerh.f:149
subroutine cerrls(PATH, NUNIT)
CERRLS
Definition: cerrls.f:57
subroutine saxpy(N, SA, SX, INCX, SY, INCY)
SAXPY
Definition: saxpy.f:54
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
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
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
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:69
subroutine clarnv(IDIST, ISEED, N, X)
CLARNV returns a vector of random numbers from a uniform or normal distribution.
Definition: clarnv.f:101
subroutine xlaenv(ISPEC, NVALUE)
XLAENV
Definition: xlaenv.f:83
real function cqrt17(TRANS, IRESID, M, N, NRHS, A, LDA, X, LDX, B, LDB, C, WORK, LWORK)
CQRT17
Definition: cqrt17.f:152
subroutine csscal(N, SA, CX, INCX)
CSSCAL
Definition: csscal.f:54
subroutine cgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
CGEMM
Definition: cgemm.f:189
subroutine cqrt15(SCALE, RKSEL, M, N, NRHS, A, LDA, B, LDB, S, RANK, NORMA, NORMB, ISEED, WORK, LWORK)
CQRT15
Definition: cqrt15.f:151
subroutine cqrt16(TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
CQRT16
Definition: cqrt16.f:135
subroutine cgelsx(M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK, WORK, RWORK, INFO)
CGELSX solves overdetermined or underdetermined systems for GE matrices
Definition: cgelsx.f:186
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

Here is the call graph for this function:

Here is the caller graph for this function: