LAPACK  3.6.1
LAPACK: Linear Algebra PACKage
subroutine zdrvls ( 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,
double precision  THRESH,
logical  TSTERR,
complex*16, dimension( * )  A,
complex*16, dimension( * )  COPYA,
complex*16, dimension( * )  B,
complex*16, dimension( * )  COPYB,
complex*16, dimension( * )  C,
double precision, dimension( * )  S,
double precision, dimension( * )  COPYS,
complex*16, dimension( * )  WORK,
double precision, dimension( * )  RWORK,
integer, dimension( * )  IWORK,
integer  NOUT 
)

ZDRVLS

Purpose: 
 ZDRVLS tests the least squares driver routines ZGELS, CGELSS, ZGELSY
 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 DOUBLE PRECISION
          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*16 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*16 array, dimension (MMAX*NMAX)
[out]B
          B is COMPLEX*16 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*16 array, dimension (MMAX*NSMAX)
[out]C
          C is COMPLEX*16 array, dimension (MMAX*NSMAX)
[out]S
          S is DOUBLE PRECISION array, dimension
                      (min(MMAX,NMAX))
[out]COPYS
          COPYS is DOUBLE PRECISION array, dimension
                      (min(MMAX,NMAX))
[out]WORK
          WORK is COMPLEX*16 array, dimension
                      (MMAX*NMAX + 4*NMAX + MMAX).
[out]RWORK
          RWORK is DOUBLE PRECISION 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 2015

Definition at line 211 of file zdrvls.f.

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 *
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
zqrt12
double precision function zqrt12(M, N, A, LDA, S, WORK, LWORK, RWORK)
ZQRT12
Definition: zqrt12.f:99
dlamch
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:65
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
zqrt14
double precision function zqrt14(TRANS, M, N, NRHS, A, LDA, X, LDX, WORK, LWORK)
ZQRT14
Definition: zqrt14.f:118
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
zqrt13
subroutine zqrt13(SCALE, M, N, A, LDA, NORMA, ISEED)
ZQRT13
Definition: zqrt13.f:93
dasum
double precision function dasum(N, DX, INCX)
DASUM
Definition: dasum.f:53
zerrls
subroutine zerrls(PATH, NUNIT)
ZERRLS
Definition: zerrls.f:57
zdscal
subroutine zdscal(N, DA, ZX, INCX)
ZDSCAL
Definition: zdscal.f:54
zqrt17
double precision function zqrt17(TRANS, IRESID, M, N, NRHS, A, LDA, X, LDX, B, LDB, C, WORK, LWORK)
ZQRT17
Definition: zqrt17.f:152
zqrt15
subroutine zqrt15(SCALE, RKSEL, M, N, NRHS, A, LDA, B, LDB, S, RANK, NORMA, NORMB, ISEED, WORK, LWORK)
ZQRT15
Definition: zqrt15.f:151

Here is the call graph for this function:

Here is the caller graph for this function: