Loading...
Searching...
No Matches

## dgesvdx()

subroutine dgesvdx | ( | character | jobu,
|  | character | jobvt,
|  | character | range,
|  | integer | m,
|  | integer | n,
|  | double precision, dimension( lda, * ) | a,
|  | integer | lda,
|  | double precision | vl,
|  | double precision | vu,
|  | integer | il,
|  | integer | iu,
|  | integer | ns,
|  | double precision, dimension( * ) | s,
|  | double precision, dimension( ldu, * ) | u,
|  | integer | ldu,
|  | double precision, dimension( ldvt, * ) | vt,
|  | integer | ldvt,
|  | double precision, dimension( * ) | work,
|  | integer | lwork,
|  | integer, dimension( * ) | iwork,
|  | integer | info )

DGESVDX computes the singular value decomposition (SVD) for GE matrices

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

Purpose:

      !>
      !>  DGESVDX computes the singular value decomposition (SVD) of a real
      !>  M-by-N matrix A, optionally computing the left and/or right singular
      !>  vectors. The SVD is written
      !>
      !>      A = U * SIGMA * transpose(V)
      !>
      !>  where SIGMA is an M-by-N matrix which is zero except for its
      !>  min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and
      !>  V is an N-by-N orthogonal matrix.  The diagonal elements of SIGMA
      !>  are the singular values of A; they are real and non-negative, and
      !>  are returned in descending order.  The first min(m,n) columns of
      !>  U and V are the left and right singular vectors of A.
      !>
      !>  DGESVDX uses an eigenvalue problem for obtaining the SVD, which
      !>  allows for the computation of a subset of singular values and
      !>  vectors. See DBDSVDX for details.
      !>
      !>  Note that the routine returns V**T, not V.
      !>

Parameters

  [in]

  JOBU

      !>          JOBU is CHARACTER*1
      !>          Specifies options for computing all or part of the matrix U:
      !>          = 'V':  the first min(m,n) columns of U (the left singular
      !>                  vectors) or as specified by RANGE are returned in
      !>                  the array U;
      !>          = 'N':  no columns of U (no left singular vectors) are
      !>                  computed.
      !>

  [in]

  JOBVT

      !>          JOBVT is CHARACTER*1
      !>           Specifies options for computing all or part of the matrix
      !>           V**T:
      !>           = 'V':  the first min(m,n) rows of V**T (the right singular
      !>                   vectors) or as specified by RANGE are returned in
      !>                   the array VT;
      !>           = 'N':  no rows of V**T (no right singular vectors) are
      !>                   computed.
      !>

  [in]

  RANGE

      !>          RANGE is CHARACTER*1
      !>          = 'A': all singular values will be found.
      !>          = 'V': all singular values in the half-open interval (VL,VU]
      !>                 will be found.
      !>          = 'I': the IL-th through IU-th singular values will be found.
      !>

  [in]

  M

      !>          M is INTEGER
      !>          The number of rows of the input matrix A.  M >= 0.
      !>

  [in]

  N

      !>          N is INTEGER
      !>          The number of columns of the input matrix A.  N >= 0.
      !>

  [in,out]

  A

      !>          A is DOUBLE PRECISION array, dimension (LDA,N)
      !>          On entry, the M-by-N matrix A.
      !>          On exit, the contents of A are destroyed.
      !>

  [in]

  LDA

      !>          LDA is INTEGER
      !>          The leading dimension of the array A.  LDA >= max(1,M).
      !>

  [in]

  VL

      !>          VL is DOUBLE PRECISION
      !>          If RANGE='V', the lower bound of the interval to
      !>          be searched for singular values. VU > VL.
      !>          Not referenced if RANGE = 'A' or 'I'.
      !>

  [in]

  VU

      !>          VU is DOUBLE PRECISION
      !>          If RANGE='V', the upper bound of the interval to
      !>          be searched for singular values. VU > VL.
      !>          Not referenced if RANGE = 'A' or 'I'.
      !>

  [in]

  IL

      !>          IL is INTEGER
      !>          If RANGE='I', the index of the
      !>          smallest singular value to be returned.
      !>          1 <= IL <= IU <= min(M,N), if min(M,N) > 0.
      !>          Not referenced if RANGE = 'A' or 'V'.
      !>

  [in]

  IU

      !>          IU is INTEGER
      !>          If RANGE='I', the index of the
      !>          largest singular value to be returned.
      !>          1 <= IL <= IU <= min(M,N), if min(M,N) > 0.
      !>          Not referenced if RANGE = 'A' or 'V'.
      !>

  [out]

  NS

      !>          NS is INTEGER
      !>          The total number of singular values found,
      !>          0 <= NS <= min(M,N).
      !>          If RANGE = 'A', NS = min(M,N); if RANGE = 'I', NS = IU-IL+1.
      !>

  [out]

  S

      !>          S is DOUBLE PRECISION array, dimension (min(M,N))
      !>          The singular values of A, sorted so that S(i) >= S(i+1).
      !>

  [out]

  U

      !>          U is DOUBLE PRECISION array, dimension (LDU,UCOL)
      !>          If JOBU = 'V', U contains columns of U (the left singular
      !>          vectors, stored columnwise) as specified by RANGE; if
      !>          JOBU = 'N', U is not referenced.
      !>          Note: The user must ensure that UCOL >= NS; if RANGE = 'V',
      !>          the exact value of NS is not known in advance and an upper
      !>          bound must be used.
      !>

  [in]

  LDU

      !>          LDU is INTEGER
      !>          The leading dimension of the array U.  LDU >= 1; if
      !>          JOBU = 'V', LDU >= M.
      !>

  [out]

  VT

      !>          VT is DOUBLE PRECISION array, dimension (LDVT,N)
      !>          If JOBVT = 'V', VT contains the rows of V**T (the right singular
      !>          vectors, stored rowwise) as specified by RANGE; if JOBVT = 'N',
      !>          VT is not referenced.
      !>          Note: The user must ensure that LDVT >= NS; if RANGE = 'V',
      !>          the exact value of NS is not known in advance and an upper
      !>          bound must be used.
      !>

  [in]

  LDVT

      !>          LDVT is INTEGER
      !>          The leading dimension of the array VT.  LDVT >= 1; if
      !>          JOBVT = 'V', LDVT >= NS (see above).
      !>

  [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 >= MAX(1,MIN(M,N)*(MIN(M,N)+4)) for the paths (see
      !>          comments inside the code):
      !>             - PATH 1  (M much larger than N)
      !>             - PATH 1t (N much larger than M)
      !>          LWORK >= MAX(1,MIN(M,N)*2+MAX(M,N)) for the other paths.
      !>          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 (12*MIN(M,N))
      !>          If INFO = 0, the first NS elements of IWORK are zero. If INFO > 0,
      !>          then IWORK contains the indices of the eigenvectors that failed
      !>          to converge in DBDSVDX/DSTEVX.
      !>

  [out]

  INFO

      !>     INFO is INTEGER
      !>           = 0:  successful exit
      !>           < 0:  if INFO = -i, the i-th argument had an illegal value
      !>           > 0:  if INFO = i, then i eigenvectors failed to converge
      !>                 in DBDSVDX/DSTEVX.
      !>                 if INFO = N*2 + 1, an internal error occurred in
      !>                 DBDSVDX
      !>

Author
  Univ. of Tennessee
  Univ. of California Berkeley
  Univ. of Colorado Denver
  NAG Ltd.