LAPACK  3.9.1
LAPACK: Linear Algebra PACKage

◆ dgelsd()

subroutine dgelsd ( integer  M,
integer  N,
integer  NRHS,
double precision, dimension( lda, * )  A,
integer  LDA,
double precision, dimension( ldb, * )  B,
integer  LDB,
double precision, dimension( * )  S,
double precision  RCOND,
integer  RANK,
double precision, dimension( * )  WORK,
integer  LWORK,
integer, dimension( * )  IWORK,
integer  INFO 
)

DGELSD computes the minimum-norm solution to a linear least squares problem for GE matrices

Download DGELSD + dependencies [TGZ] [ZIP] [TXT]

Purpose:
 DGELSD computes the minimum-norm solution to a real linear least
 squares problem:
     minimize 2-norm(| b - A*x |)
 using the singular value decomposition (SVD) of A. A is an M-by-N
 matrix which may be rank-deficient.

 Several right hand side vectors b and solution vectors x can be
 handled in a single call; they are stored as the columns of the
 M-by-NRHS right hand side matrix B and the N-by-NRHS solution
 matrix X.

 The problem is solved in three steps:
 (1) Reduce the coefficient matrix A to bidiagonal form with
     Householder transformations, reducing the original problem
     into a "bidiagonal least squares problem" (BLS)
 (2) Solve the BLS using a divide and conquer approach.
 (3) Apply back all the Householder transformations to solve
     the original least squares problem.

 The effective rank of A is determined by treating as zero those
 singular values which are less than RCOND times the largest singular
 value.

 The divide and conquer algorithm makes very mild assumptions about
 floating point arithmetic. It will work on machines with a guard
 digit in add/subtract, or on those binary machines without guard
 digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or
 Cray-2. It could conceivably fail on hexadecimal or decimal machines
 without guard digits, but we know of none.
Parameters
[in]M
          M is INTEGER
          The number of rows of A. M >= 0.
[in]N
          N is INTEGER
          The number of columns of A. N >= 0.
[in]NRHS
          NRHS is INTEGER
          The number of right hand sides, i.e., the number of columns
          of the matrices B and X. NRHS >= 0.
[in,out]A
          A is DOUBLE PRECISION array, dimension (LDA,N)
          On entry, the M-by-N matrix A.
          On exit, A has been destroyed.
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,M).
[in,out]B
          B is DOUBLE PRECISION array, dimension (LDB,NRHS)
          On entry, the M-by-NRHS right hand side matrix B.
          On exit, B is overwritten by the N-by-NRHS solution
          matrix X.  If m >= n and RANK = n, the residual
          sum-of-squares for the solution in the i-th column is given
          by the sum of squares of elements n+1:m in that column.
[in]LDB
          LDB is INTEGER
          The leading dimension of the array B. LDB >= max(1,max(M,N)).
[out]S
          S is DOUBLE PRECISION array, dimension (min(M,N))
          The singular values of A in decreasing order.
          The condition number of A in the 2-norm = S(1)/S(min(m,n)).
[in]RCOND
          RCOND is DOUBLE PRECISION
          RCOND is used to determine the effective rank of A.
          Singular values S(i) <= RCOND*S(1) are treated as zero.
          If RCOND < 0, machine precision is used instead.
[out]RANK
          RANK is INTEGER
          The effective rank of A, i.e., the number of singular values
          which are greater than RCOND*S(1).
[out]WORK
          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
[in]LWORK
          LWORK is INTEGER
          The dimension of the array WORK. LWORK must be at least 1.
          The exact minimum amount of workspace needed depends on M,
          N and NRHS. As long as LWORK is at least
              12*N + 2*N*SMLSIZ + 8*N*NLVL + N*NRHS + (SMLSIZ+1)**2,
          if M is greater than or equal to N or
              12*M + 2*M*SMLSIZ + 8*M*NLVL + M*NRHS + (SMLSIZ+1)**2,
          if M is less than N, the code will execute correctly.
          SMLSIZ is returned by ILAENV and is equal to the maximum
          size of the subproblems at the bottom of the computation
          tree (usually about 25), and
             NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 )
          For good performance, LWORK should generally be larger.

          If LWORK = -1, then a workspace query is assumed; the routine
          only calculates the optimal size of the WORK array, returns
          this value as the first entry of the WORK array, and no error
          message related to LWORK is issued by XERBLA.
[out]IWORK
          IWORK is INTEGER array, dimension (MAX(1,LIWORK))
          LIWORK >= max(1, 3 * MINMN * NLVL + 11 * MINMN),
          where MINMN = MIN( M,N ).
          On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK.
[out]INFO
          INFO is INTEGER
          = 0:  successful exit
          < 0:  if INFO = -i, the i-th argument had an illegal value.
          > 0:  the algorithm for computing the SVD failed to converge;
                if INFO = i, i off-diagonal elements of an intermediate
                bidiagonal form did not converge to zero.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Contributors:
Ming Gu and Ren-Cang Li, Computer Science Division, University of California at Berkeley, USA
Osni Marques, LBNL/NERSC, USA

Definition at line 207 of file dgelsd.f.

209 *
210 * -- LAPACK driver routine --
211 * -- LAPACK is a software package provided by Univ. of Tennessee, --
212 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
213 *
214 * .. Scalar Arguments ..
215  INTEGER INFO, LDA, LDB, LWORK, M, N, NRHS, RANK
216  DOUBLE PRECISION RCOND
217 * ..
218 * .. Array Arguments ..
219  INTEGER IWORK( * )
220  DOUBLE PRECISION A( LDA, * ), B( LDB, * ), S( * ), WORK( * )
221 * ..
222 *
223 * =====================================================================
224 *
225 * .. Parameters ..
226  DOUBLE PRECISION ZERO, ONE, TWO
227  parameter( zero = 0.0d0, one = 1.0d0, two = 2.0d0 )
228 * ..
229 * .. Local Scalars ..
230  LOGICAL LQUERY
231  INTEGER IASCL, IBSCL, IE, IL, ITAU, ITAUP, ITAUQ,
232  $ LDWORK, LIWORK, MAXMN, MAXWRK, MINMN, MINWRK,
233  $ MM, MNTHR, NLVL, NWORK, SMLSIZ, WLALSD
234  DOUBLE PRECISION ANRM, BIGNUM, BNRM, EPS, SFMIN, SMLNUM
235 * ..
236 * .. External Subroutines ..
237  EXTERNAL dgebrd, dgelqf, dgeqrf, dlabad, dlacpy, dlalsd,
239 * ..
240 * .. External Functions ..
241  INTEGER ILAENV
242  DOUBLE PRECISION DLAMCH, DLANGE
243  EXTERNAL ilaenv, dlamch, dlange
244 * ..
245 * .. Intrinsic Functions ..
246  INTRINSIC dble, int, log, max, min
247 * ..
248 * .. Executable Statements ..
249 *
250 * Test the input arguments.
251 *
252  info = 0
253  minmn = min( m, n )
254  maxmn = max( m, n )
255  mnthr = ilaenv( 6, 'DGELSD', ' ', m, n, nrhs, -1 )
256  lquery = ( lwork.EQ.-1 )
257  IF( m.LT.0 ) THEN
258  info = -1
259  ELSE IF( n.LT.0 ) THEN
260  info = -2
261  ELSE IF( nrhs.LT.0 ) THEN
262  info = -3
263  ELSE IF( lda.LT.max( 1, m ) ) THEN
264  info = -5
265  ELSE IF( ldb.LT.max( 1, maxmn ) ) THEN
266  info = -7
267  END IF
268 *
269  smlsiz = ilaenv( 9, 'DGELSD', ' ', 0, 0, 0, 0 )
270 *
271 * Compute workspace.
272 * (Note: Comments in the code beginning "Workspace:" describe the
273 * minimal amount of workspace needed at that point in the code,
274 * as well as the preferred amount for good performance.
275 * NB refers to the optimal block size for the immediately
276 * following subroutine, as returned by ILAENV.)
277 *
278  minwrk = 1
279  liwork = 1
280  minmn = max( 1, minmn )
281  nlvl = max( int( log( dble( minmn ) / dble( smlsiz+1 ) ) /
282  $ log( two ) ) + 1, 0 )
283 *
284  IF( info.EQ.0 ) THEN
285  maxwrk = 0
286  liwork = 3*minmn*nlvl + 11*minmn
287  mm = m
288  IF( m.GE.n .AND. m.GE.mnthr ) THEN
289 *
290 * Path 1a - overdetermined, with many more rows than columns.
291 *
292  mm = n
293  maxwrk = max( maxwrk, n+n*ilaenv( 1, 'DGEQRF', ' ', m, n,
294  $ -1, -1 ) )
295  maxwrk = max( maxwrk, n+nrhs*
296  $ ilaenv( 1, 'DORMQR', 'LT', m, nrhs, n, -1 ) )
297  END IF
298  IF( m.GE.n ) THEN
299 *
300 * Path 1 - overdetermined or exactly determined.
301 *
302  maxwrk = max( maxwrk, 3*n+( mm+n )*
303  $ ilaenv( 1, 'DGEBRD', ' ', mm, n, -1, -1 ) )
304  maxwrk = max( maxwrk, 3*n+nrhs*
305  $ ilaenv( 1, 'DORMBR', 'QLT', mm, nrhs, n, -1 ) )
306  maxwrk = max( maxwrk, 3*n+( n-1 )*
307  $ ilaenv( 1, 'DORMBR', 'PLN', n, nrhs, n, -1 ) )
308  wlalsd = 9*n+2*n*smlsiz+8*n*nlvl+n*nrhs+(smlsiz+1)**2
309  maxwrk = max( maxwrk, 3*n+wlalsd )
310  minwrk = max( 3*n+mm, 3*n+nrhs, 3*n+wlalsd )
311  END IF
312  IF( n.GT.m ) THEN
313  wlalsd = 9*m+2*m*smlsiz+8*m*nlvl+m*nrhs+(smlsiz+1)**2
314  IF( n.GE.mnthr ) THEN
315 *
316 * Path 2a - underdetermined, with many more columns
317 * than rows.
318 *
319  maxwrk = m + m*ilaenv( 1, 'DGELQF', ' ', m, n, -1, -1 )
320  maxwrk = max( maxwrk, m*m+4*m+2*m*
321  $ ilaenv( 1, 'DGEBRD', ' ', m, m, -1, -1 ) )
322  maxwrk = max( maxwrk, m*m+4*m+nrhs*
323  $ ilaenv( 1, 'DORMBR', 'QLT', m, nrhs, m, -1 ) )
324  maxwrk = max( maxwrk, m*m+4*m+( m-1 )*
325  $ ilaenv( 1, 'DORMBR', 'PLN', m, nrhs, m, -1 ) )
326  IF( nrhs.GT.1 ) THEN
327  maxwrk = max( maxwrk, m*m+m+m*nrhs )
328  ELSE
329  maxwrk = max( maxwrk, m*m+2*m )
330  END IF
331  maxwrk = max( maxwrk, m+nrhs*
332  $ ilaenv( 1, 'DORMLQ', 'LT', n, nrhs, m, -1 ) )
333  maxwrk = max( maxwrk, m*m+4*m+wlalsd )
334 ! XXX: Ensure the Path 2a case below is triggered. The workspace
335 ! calculation should use queries for all routines eventually.
336  maxwrk = max( maxwrk,
337  $ 4*m+m*m+max( m, 2*m-4, nrhs, n-3*m ) )
338  ELSE
339 *
340 * Path 2 - remaining underdetermined cases.
341 *
342  maxwrk = 3*m + ( n+m )*ilaenv( 1, 'DGEBRD', ' ', m, n,
343  $ -1, -1 )
344  maxwrk = max( maxwrk, 3*m+nrhs*
345  $ ilaenv( 1, 'DORMBR', 'QLT', m, nrhs, n, -1 ) )
346  maxwrk = max( maxwrk, 3*m+m*
347  $ ilaenv( 1, 'DORMBR', 'PLN', n, nrhs, m, -1 ) )
348  maxwrk = max( maxwrk, 3*m+wlalsd )
349  END IF
350  minwrk = max( 3*m+nrhs, 3*m+m, 3*m+wlalsd )
351  END IF
352  minwrk = min( minwrk, maxwrk )
353  work( 1 ) = maxwrk
354  iwork( 1 ) = liwork
355 
356  IF( lwork.LT.minwrk .AND. .NOT.lquery ) THEN
357  info = -12
358  END IF
359  END IF
360 *
361  IF( info.NE.0 ) THEN
362  CALL xerbla( 'DGELSD', -info )
363  RETURN
364  ELSE IF( lquery ) THEN
365  GO TO 10
366  END IF
367 *
368 * Quick return if possible.
369 *
370  IF( m.EQ.0 .OR. n.EQ.0 ) THEN
371  rank = 0
372  RETURN
373  END IF
374 *
375 * Get machine parameters.
376 *
377  eps = dlamch( 'P' )
378  sfmin = dlamch( 'S' )
379  smlnum = sfmin / eps
380  bignum = one / smlnum
381  CALL dlabad( smlnum, bignum )
382 *
383 * Scale A if max entry outside range [SMLNUM,BIGNUM].
384 *
385  anrm = dlange( 'M', m, n, a, lda, work )
386  iascl = 0
387  IF( anrm.GT.zero .AND. anrm.LT.smlnum ) THEN
388 *
389 * Scale matrix norm up to SMLNUM.
390 *
391  CALL dlascl( 'G', 0, 0, anrm, smlnum, m, n, a, lda, info )
392  iascl = 1
393  ELSE IF( anrm.GT.bignum ) THEN
394 *
395 * Scale matrix norm down to BIGNUM.
396 *
397  CALL dlascl( 'G', 0, 0, anrm, bignum, m, n, a, lda, info )
398  iascl = 2
399  ELSE IF( anrm.EQ.zero ) THEN
400 *
401 * Matrix all zero. Return zero solution.
402 *
403  CALL dlaset( 'F', max( m, n ), nrhs, zero, zero, b, ldb )
404  CALL dlaset( 'F', minmn, 1, zero, zero, s, 1 )
405  rank = 0
406  GO TO 10
407  END IF
408 *
409 * Scale B if max entry outside range [SMLNUM,BIGNUM].
410 *
411  bnrm = dlange( 'M', m, nrhs, b, ldb, work )
412  ibscl = 0
413  IF( bnrm.GT.zero .AND. bnrm.LT.smlnum ) THEN
414 *
415 * Scale matrix norm up to SMLNUM.
416 *
417  CALL dlascl( 'G', 0, 0, bnrm, smlnum, m, nrhs, b, ldb, info )
418  ibscl = 1
419  ELSE IF( bnrm.GT.bignum ) THEN
420 *
421 * Scale matrix norm down to BIGNUM.
422 *
423  CALL dlascl( 'G', 0, 0, bnrm, bignum, m, nrhs, b, ldb, info )
424  ibscl = 2
425  END IF
426 *
427 * If M < N make sure certain entries of B are zero.
428 *
429  IF( m.LT.n )
430  $ CALL dlaset( 'F', n-m, nrhs, zero, zero, b( m+1, 1 ), ldb )
431 *
432 * Overdetermined case.
433 *
434  IF( m.GE.n ) THEN
435 *
436 * Path 1 - overdetermined or exactly determined.
437 *
438  mm = m
439  IF( m.GE.mnthr ) THEN
440 *
441 * Path 1a - overdetermined, with many more rows than columns.
442 *
443  mm = n
444  itau = 1
445  nwork = itau + n
446 *
447 * Compute A=Q*R.
448 * (Workspace: need 2*N, prefer N+N*NB)
449 *
450  CALL dgeqrf( m, n, a, lda, work( itau ), work( nwork ),
451  $ lwork-nwork+1, info )
452 *
453 * Multiply B by transpose(Q).
454 * (Workspace: need N+NRHS, prefer N+NRHS*NB)
455 *
456  CALL dormqr( 'L', 'T', m, nrhs, n, a, lda, work( itau ), b,
457  $ ldb, work( nwork ), lwork-nwork+1, info )
458 *
459 * Zero out below R.
460 *
461  IF( n.GT.1 ) THEN
462  CALL dlaset( 'L', n-1, n-1, zero, zero, a( 2, 1 ), lda )
463  END IF
464  END IF
465 *
466  ie = 1
467  itauq = ie + n
468  itaup = itauq + n
469  nwork = itaup + n
470 *
471 * Bidiagonalize R in A.
472 * (Workspace: need 3*N+MM, prefer 3*N+(MM+N)*NB)
473 *
474  CALL dgebrd( mm, n, a, lda, s, work( ie ), work( itauq ),
475  $ work( itaup ), work( nwork ), lwork-nwork+1,
476  $ info )
477 *
478 * Multiply B by transpose of left bidiagonalizing vectors of R.
479 * (Workspace: need 3*N+NRHS, prefer 3*N+NRHS*NB)
480 *
481  CALL dormbr( 'Q', 'L', 'T', mm, nrhs, n, a, lda, work( itauq ),
482  $ b, ldb, work( nwork ), lwork-nwork+1, info )
483 *
484 * Solve the bidiagonal least squares problem.
485 *
486  CALL dlalsd( 'U', smlsiz, n, nrhs, s, work( ie ), b, ldb,
487  $ rcond, rank, work( nwork ), iwork, info )
488  IF( info.NE.0 ) THEN
489  GO TO 10
490  END IF
491 *
492 * Multiply B by right bidiagonalizing vectors of R.
493 *
494  CALL dormbr( 'P', 'L', 'N', n, nrhs, n, a, lda, work( itaup ),
495  $ b, ldb, work( nwork ), lwork-nwork+1, info )
496 *
497  ELSE IF( n.GE.mnthr .AND. lwork.GE.4*m+m*m+
498  $ max( m, 2*m-4, nrhs, n-3*m, wlalsd ) ) THEN
499 *
500 * Path 2a - underdetermined, with many more columns than rows
501 * and sufficient workspace for an efficient algorithm.
502 *
503  ldwork = m
504  IF( lwork.GE.max( 4*m+m*lda+max( m, 2*m-4, nrhs, n-3*m ),
505  $ m*lda+m+m*nrhs, 4*m+m*lda+wlalsd ) )ldwork = lda
506  itau = 1
507  nwork = m + 1
508 *
509 * Compute A=L*Q.
510 * (Workspace: need 2*M, prefer M+M*NB)
511 *
512  CALL dgelqf( m, n, a, lda, work( itau ), work( nwork ),
513  $ lwork-nwork+1, info )
514  il = nwork
515 *
516 * Copy L to WORK(IL), zeroing out above its diagonal.
517 *
518  CALL dlacpy( 'L', m, m, a, lda, work( il ), ldwork )
519  CALL dlaset( 'U', m-1, m-1, zero, zero, work( il+ldwork ),
520  $ ldwork )
521  ie = il + ldwork*m
522  itauq = ie + m
523  itaup = itauq + m
524  nwork = itaup + m
525 *
526 * Bidiagonalize L in WORK(IL).
527 * (Workspace: need M*M+5*M, prefer M*M+4*M+2*M*NB)
528 *
529  CALL dgebrd( m, m, work( il ), ldwork, s, work( ie ),
530  $ work( itauq ), work( itaup ), work( nwork ),
531  $ lwork-nwork+1, info )
532 *
533 * Multiply B by transpose of left bidiagonalizing vectors of L.
534 * (Workspace: need M*M+4*M+NRHS, prefer M*M+4*M+NRHS*NB)
535 *
536  CALL dormbr( 'Q', 'L', 'T', m, nrhs, m, work( il ), ldwork,
537  $ work( itauq ), b, ldb, work( nwork ),
538  $ lwork-nwork+1, info )
539 *
540 * Solve the bidiagonal least squares problem.
541 *
542  CALL dlalsd( 'U', smlsiz, m, nrhs, s, work( ie ), b, ldb,
543  $ rcond, rank, work( nwork ), iwork, info )
544  IF( info.NE.0 ) THEN
545  GO TO 10
546  END IF
547 *
548 * Multiply B by right bidiagonalizing vectors of L.
549 *
550  CALL dormbr( 'P', 'L', 'N', m, nrhs, m, work( il ), ldwork,
551  $ work( itaup ), b, ldb, work( nwork ),
552  $ lwork-nwork+1, info )
553 *
554 * Zero out below first M rows of B.
555 *
556  CALL dlaset( 'F', n-m, nrhs, zero, zero, b( m+1, 1 ), ldb )
557  nwork = itau + m
558 *
559 * Multiply transpose(Q) by B.
560 * (Workspace: need M+NRHS, prefer M+NRHS*NB)
561 *
562  CALL dormlq( 'L', 'T', n, nrhs, m, a, lda, work( itau ), b,
563  $ ldb, work( nwork ), lwork-nwork+1, info )
564 *
565  ELSE
566 *
567 * Path 2 - remaining underdetermined cases.
568 *
569  ie = 1
570  itauq = ie + m
571  itaup = itauq + m
572  nwork = itaup + m
573 *
574 * Bidiagonalize A.
575 * (Workspace: need 3*M+N, prefer 3*M+(M+N)*NB)
576 *
577  CALL dgebrd( m, n, a, lda, s, work( ie ), work( itauq ),
578  $ work( itaup ), work( nwork ), lwork-nwork+1,
579  $ info )
580 *
581 * Multiply B by transpose of left bidiagonalizing vectors.
582 * (Workspace: need 3*M+NRHS, prefer 3*M+NRHS*NB)
583 *
584  CALL dormbr( 'Q', 'L', 'T', m, nrhs, n, a, lda, work( itauq ),
585  $ b, ldb, work( nwork ), lwork-nwork+1, info )
586 *
587 * Solve the bidiagonal least squares problem.
588 *
589  CALL dlalsd( 'L', smlsiz, m, nrhs, s, work( ie ), b, ldb,
590  $ rcond, rank, work( nwork ), iwork, info )
591  IF( info.NE.0 ) THEN
592  GO TO 10
593  END IF
594 *
595 * Multiply B by right bidiagonalizing vectors of A.
596 *
597  CALL dormbr( 'P', 'L', 'N', n, nrhs, m, a, lda, work( itaup ),
598  $ b, ldb, work( nwork ), lwork-nwork+1, info )
599 *
600  END IF
601 *
602 * Undo scaling.
603 *
604  IF( iascl.EQ.1 ) THEN
605  CALL dlascl( 'G', 0, 0, anrm, smlnum, n, nrhs, b, ldb, info )
606  CALL dlascl( 'G', 0, 0, smlnum, anrm, minmn, 1, s, minmn,
607  $ info )
608  ELSE IF( iascl.EQ.2 ) THEN
609  CALL dlascl( 'G', 0, 0, anrm, bignum, n, nrhs, b, ldb, info )
610  CALL dlascl( 'G', 0, 0, bignum, anrm, minmn, 1, s, minmn,
611  $ info )
612  END IF
613  IF( ibscl.EQ.1 ) THEN
614  CALL dlascl( 'G', 0, 0, smlnum, bnrm, n, nrhs, b, ldb, info )
615  ELSE IF( ibscl.EQ.2 ) THEN
616  CALL dlascl( 'G', 0, 0, bignum, bnrm, n, nrhs, b, ldb, info )
617  END IF
618 *
619  10 CONTINUE
620  work( 1 ) = maxwrk
621  iwork( 1 ) = liwork
622  RETURN
623 *
624 * End of DGELSD
625 *
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:69
subroutine dlabad(SMALL, LARGE)
DLABAD
Definition: dlabad.f:74
subroutine dlascl(TYPE, KL, KU, CFROM, CTO, M, N, A, LDA, INFO)
DLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.
Definition: dlascl.f:143
subroutine dlacpy(UPLO, M, N, A, LDA, B, LDB)
DLACPY copies all or part of one two-dimensional array to another.
Definition: dlacpy.f:103
subroutine dlaset(UPLO, M, N, ALPHA, BETA, A, LDA)
DLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition: dlaset.f:110
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: ilaenv.f:162
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
double precision function dlange(NORM, M, N, A, LDA, WORK)
DLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition: dlange.f:114
subroutine dgeqrf(M, N, A, LDA, TAU, WORK, LWORK, INFO)
DGEQRF
Definition: dgeqrf.f:145
subroutine dgelqf(M, N, A, LDA, TAU, WORK, LWORK, INFO)
DGELQF
Definition: dgelqf.f:143
subroutine dgebrd(M, N, A, LDA, D, E, TAUQ, TAUP, WORK, LWORK, INFO)
DGEBRD
Definition: dgebrd.f:205
subroutine dormqr(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
DORMQR
Definition: dormqr.f:167
subroutine dormlq(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
DORMLQ
Definition: dormlq.f:167
subroutine dlalsd(UPLO, SMLSIZ, N, NRHS, D, E, B, LDB, RCOND, RANK, WORK, IWORK, INFO)
DLALSD uses the singular value decomposition of A to solve the least squares problem.
Definition: dlalsd.f:179
subroutine dormbr(VECT, SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
DORMBR
Definition: dormbr.f:195
Here is the call graph for this function:
Here is the caller graph for this function: