Improve inline documentation of ?GEJSV (Reference-LAPACK PR 750)
This commit is contained in:
parent
871b730dc5
commit
164eafd61d
|
@ -304,7 +304,7 @@
|
||||||
*> -> the minimal requirement is LWORK >= 3*N.
|
*> -> the minimal requirement is LWORK >= 3*N.
|
||||||
*> -> For optimal performance,
|
*> -> For optimal performance,
|
||||||
*> LWORK >= max(N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,
|
*> LWORK >= max(N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,
|
||||||
*> where NB is the optimal block size for CGEQP3, CGEQRF, CGELQ,
|
*> where NB is the optimal block size for CGEQP3, CGEQRF, CGELQF,
|
||||||
*> CUNMLQ. In general, the optimal length LWORK is computed as
|
*> CUNMLQ. In general, the optimal length LWORK is computed as
|
||||||
*> LWORK >= max(N+LWORK(CGEQP3), N+LWORK(CGESVJ),
|
*> LWORK >= max(N+LWORK(CGEQP3), N+LWORK(CGESVJ),
|
||||||
*> N+LWORK(CGELQF), 2*N+LWORK(CGEQRF), N+LWORK(CUNMLQ)).
|
*> N+LWORK(CGELQF), 2*N+LWORK(CGEQRF), N+LWORK(CUNMLQ)).
|
||||||
|
@ -313,7 +313,7 @@
|
||||||
*> -> the minimal requirement is LWORK >= 3*N.
|
*> -> the minimal requirement is LWORK >= 3*N.
|
||||||
*> -> For optimal performance,
|
*> -> For optimal performance,
|
||||||
*> LWORK >= max(N+(N+1)*NB, 2*N,2*N+N*NB)=2*N+N*NB,
|
*> LWORK >= max(N+(N+1)*NB, 2*N,2*N+N*NB)=2*N+N*NB,
|
||||||
*> where NB is the optimal block size for CGEQP3, CGEQRF, CGELQ,
|
*> where NB is the optimal block size for CGEQP3, CGEQRF, CGELQF,
|
||||||
*> CUNMLQ. In general, the optimal length LWORK is computed as
|
*> CUNMLQ. In general, the optimal length LWORK is computed as
|
||||||
*> LWORK >= max(N+LWORK(CGEQP3), LWORK(CPOCON), N+LWORK(CGESVJ),
|
*> LWORK >= max(N+LWORK(CGEQP3), LWORK(CPOCON), N+LWORK(CGESVJ),
|
||||||
*> N+LWORK(CGELQF), 2*N+LWORK(CGEQRF), N+LWORK(CUNMLQ)).
|
*> N+LWORK(CGELQF), 2*N+LWORK(CGEQRF), N+LWORK(CUNMLQ)).
|
||||||
|
@ -350,7 +350,7 @@
|
||||||
*>
|
*>
|
||||||
*> \param[out] RWORK
|
*> \param[out] RWORK
|
||||||
*> \verbatim
|
*> \verbatim
|
||||||
*> RWORK is REAL array, dimension (MAX(7,LWORK))
|
*> RWORK is REAL array, dimension (MAX(7,LRWORK))
|
||||||
*> On exit,
|
*> On exit,
|
||||||
*> RWORK(1) = Determines the scaling factor SCALE = RWORK(2) / RWORK(1)
|
*> RWORK(1) = Determines the scaling factor SCALE = RWORK(2) / RWORK(1)
|
||||||
*> such that SCALE*SVA(1:N) are the computed singular values
|
*> such that SCALE*SVA(1:N) are the computed singular values
|
||||||
|
|
|
@ -224,7 +224,7 @@
|
||||||
*>
|
*>
|
||||||
*> \param[out] U
|
*> \param[out] U
|
||||||
*> \verbatim
|
*> \verbatim
|
||||||
*> U is DOUBLE PRECISION array, dimension ( LDU, N )
|
*> U is DOUBLE PRECISION array, dimension ( LDU, N ) or ( LDU, M )
|
||||||
*> If JOBU = 'U', then U contains on exit the M-by-N matrix of
|
*> If JOBU = 'U', then U contains on exit the M-by-N matrix of
|
||||||
*> the left singular vectors.
|
*> the left singular vectors.
|
||||||
*> If JOBU = 'F', then U contains on exit the M-by-M matrix of
|
*> If JOBU = 'F', then U contains on exit the M-by-M matrix of
|
||||||
|
@ -271,7 +271,7 @@
|
||||||
*>
|
*>
|
||||||
*> \param[out] WORK
|
*> \param[out] WORK
|
||||||
*> \verbatim
|
*> \verbatim
|
||||||
*> WORK is DOUBLE PRECISION array, dimension (LWORK)
|
*> WORK is DOUBLE PRECISION array, dimension (MAX(7,LWORK))
|
||||||
*> On exit, if N > 0 .AND. M > 0 (else not referenced),
|
*> On exit, if N > 0 .AND. M > 0 (else not referenced),
|
||||||
*> WORK(1) = SCALE = WORK(2) / WORK(1) is the scaling factor such
|
*> WORK(1) = SCALE = WORK(2) / WORK(1) is the scaling factor such
|
||||||
*> that SCALE*SVA(1:N) are the computed singular values
|
*> that SCALE*SVA(1:N) are the computed singular values
|
||||||
|
|
|
@ -224,7 +224,7 @@
|
||||||
*>
|
*>
|
||||||
*> \param[out] U
|
*> \param[out] U
|
||||||
*> \verbatim
|
*> \verbatim
|
||||||
*> U is REAL array, dimension ( LDU, N )
|
*> U is REAL array, dimension ( LDU, N ) or ( LDU, M )
|
||||||
*> If JOBU = 'U', then U contains on exit the M-by-N matrix of
|
*> If JOBU = 'U', then U contains on exit the M-by-N matrix of
|
||||||
*> the left singular vectors.
|
*> the left singular vectors.
|
||||||
*> If JOBU = 'F', then U contains on exit the M-by-M matrix of
|
*> If JOBU = 'F', then U contains on exit the M-by-M matrix of
|
||||||
|
@ -271,7 +271,7 @@
|
||||||
*>
|
*>
|
||||||
*> \param[out] WORK
|
*> \param[out] WORK
|
||||||
*> \verbatim
|
*> \verbatim
|
||||||
*> WORK is REAL array, dimension (LWORK)
|
*> WORK is REAL array, dimension (MAX(7,LWORK))
|
||||||
*> On exit,
|
*> On exit,
|
||||||
*> WORK(1) = SCALE = WORK(2) / WORK(1) is the scaling factor such
|
*> WORK(1) = SCALE = WORK(2) / WORK(1) is the scaling factor such
|
||||||
*> that SCALE*SVA(1:N) are the computed singular values
|
*> that SCALE*SVA(1:N) are the computed singular values
|
||||||
|
@ -318,36 +318,36 @@
|
||||||
*> LWORK >= max(2*M+N,4*N+1,7). This is the minimal requirement.
|
*> LWORK >= max(2*M+N,4*N+1,7). This is the minimal requirement.
|
||||||
*> ->> For optimal performance (blocked code) the optimal value
|
*> ->> For optimal performance (blocked code) the optimal value
|
||||||
*> is LWORK >= max(2*M+N,3*N+(N+1)*NB,7). Here NB is the optimal
|
*> is LWORK >= max(2*M+N,3*N+(N+1)*NB,7). Here NB is the optimal
|
||||||
*> block size for DGEQP3 and DGEQRF.
|
*> block size for SGEQP3 and SGEQRF.
|
||||||
*> In general, optimal LWORK is computed as
|
*> In general, optimal LWORK is computed as
|
||||||
*> LWORK >= max(2*M+N,N+LWORK(DGEQP3),N+LWORK(DGEQRF), 7).
|
*> LWORK >= max(2*M+N,N+LWORK(SGEQP3),N+LWORK(SGEQRF), 7).
|
||||||
*> -> .. an estimate of the scaled condition number of A is
|
*> -> .. an estimate of the scaled condition number of A is
|
||||||
*> required (JOBA='E', 'G'). In this case, LWORK is the maximum
|
*> required (JOBA='E', 'G'). In this case, LWORK is the maximum
|
||||||
*> of the above and N*N+4*N, i.e. LWORK >= max(2*M+N,N*N+4*N,7).
|
*> of the above and N*N+4*N, i.e. LWORK >= max(2*M+N,N*N+4*N,7).
|
||||||
*> ->> For optimal performance (blocked code) the optimal value
|
*> ->> For optimal performance (blocked code) the optimal value
|
||||||
*> is LWORK >= max(2*M+N,3*N+(N+1)*NB, N*N+4*N, 7).
|
*> is LWORK >= max(2*M+N,3*N+(N+1)*NB, N*N+4*N, 7).
|
||||||
*> In general, the optimal length LWORK is computed as
|
*> In general, the optimal length LWORK is computed as
|
||||||
*> LWORK >= max(2*M+N,N+LWORK(DGEQP3),N+LWORK(DGEQRF),
|
*> LWORK >= max(2*M+N,N+LWORK(SGEQP3),N+LWORK(SGEQRF),
|
||||||
*> N+N*N+LWORK(DPOCON),7).
|
*> N+N*N+LWORK(SPOCON),7).
|
||||||
*>
|
*>
|
||||||
*> If SIGMA and the right singular vectors are needed (JOBV = 'V'),
|
*> If SIGMA and the right singular vectors are needed (JOBV = 'V'),
|
||||||
*> -> the minimal requirement is LWORK >= max(2*M+N,4*N+1,7).
|
*> -> the minimal requirement is LWORK >= max(2*M+N,4*N+1,7).
|
||||||
*> -> For optimal performance, LWORK >= max(2*M+N,3*N+(N+1)*NB,7),
|
*> -> For optimal performance, LWORK >= max(2*M+N,3*N+(N+1)*NB,7),
|
||||||
*> where NB is the optimal block size for DGEQP3, DGEQRF, DGELQ,
|
*> where NB is the optimal block size for SGEQP3, SGEQRF, SGELQF,
|
||||||
*> DORMLQ. In general, the optimal length LWORK is computed as
|
*> SORMLQ. In general, the optimal length LWORK is computed as
|
||||||
*> LWORK >= max(2*M+N,N+LWORK(DGEQP3), N+LWORK(DPOCON),
|
*> LWORK >= max(2*M+N,N+LWORK(SGEQP3), N+LWORK(SPOCON),
|
||||||
*> N+LWORK(DGELQ), 2*N+LWORK(DGEQRF), N+LWORK(DORMLQ)).
|
*> N+LWORK(SGELQF), 2*N+LWORK(SGEQRF), N+LWORK(SORMLQ)).
|
||||||
*>
|
*>
|
||||||
*> If SIGMA and the left singular vectors are needed
|
*> If SIGMA and the left singular vectors are needed
|
||||||
*> -> the minimal requirement is LWORK >= max(2*M+N,4*N+1,7).
|
*> -> the minimal requirement is LWORK >= max(2*M+N,4*N+1,7).
|
||||||
*> -> For optimal performance:
|
*> -> For optimal performance:
|
||||||
*> if JOBU = 'U' :: LWORK >= max(2*M+N,3*N+(N+1)*NB,7),
|
*> if JOBU = 'U' :: LWORK >= max(2*M+N,3*N+(N+1)*NB,7),
|
||||||
*> if JOBU = 'F' :: LWORK >= max(2*M+N,3*N+(N+1)*NB,N+M*NB,7),
|
*> if JOBU = 'F' :: LWORK >= max(2*M+N,3*N+(N+1)*NB,N+M*NB,7),
|
||||||
*> where NB is the optimal block size for DGEQP3, DGEQRF, DORMQR.
|
*> where NB is the optimal block size for SGEQP3, SGEQRF, SORMQR.
|
||||||
*> In general, the optimal length LWORK is computed as
|
*> In general, the optimal length LWORK is computed as
|
||||||
*> LWORK >= max(2*M+N,N+LWORK(DGEQP3),N+LWORK(DPOCON),
|
*> LWORK >= max(2*M+N,N+LWORK(SGEQP3),N+LWORK(SPOCON),
|
||||||
*> 2*N+LWORK(DGEQRF), N+LWORK(DORMQR)).
|
*> 2*N+LWORK(SGEQRF), N+LWORK(SORMQR)).
|
||||||
*> Here LWORK(DORMQR) equals N*NB (for JOBU = 'U') or
|
*> Here LWORK(SORMQR) equals N*NB (for JOBU = 'U') or
|
||||||
*> M*NB (for JOBU = 'F').
|
*> M*NB (for JOBU = 'F').
|
||||||
*>
|
*>
|
||||||
*> If the full SVD is needed: (JOBU = 'U' or JOBU = 'F') and
|
*> If the full SVD is needed: (JOBU = 'U' or JOBU = 'F') and
|
||||||
|
@ -357,12 +357,12 @@
|
||||||
*> LWORK >= max(2*M+N, 4*N+N*N,2*N+N*N+6).
|
*> LWORK >= max(2*M+N, 4*N+N*N,2*N+N*N+6).
|
||||||
*> -> For optimal performance, LWORK should be additionally
|
*> -> For optimal performance, LWORK should be additionally
|
||||||
*> larger than N+M*NB, where NB is the optimal block size
|
*> larger than N+M*NB, where NB is the optimal block size
|
||||||
*> for DORMQR.
|
*> for SORMQR.
|
||||||
*> \endverbatim
|
*> \endverbatim
|
||||||
*>
|
*>
|
||||||
*> \param[out] IWORK
|
*> \param[out] IWORK
|
||||||
*> \verbatim
|
*> \verbatim
|
||||||
*> IWORK is INTEGER array, dimension (M+3*N).
|
*> IWORK is INTEGER array, dimension (MAX(3,M+3*N)).
|
||||||
*> On exit,
|
*> On exit,
|
||||||
*> IWORK(1) = the numerical rank determined after the initial
|
*> IWORK(1) = the numerical rank determined after the initial
|
||||||
*> QR factorization with pivoting. See the descriptions
|
*> QR factorization with pivoting. See the descriptions
|
||||||
|
|
|
@ -304,7 +304,7 @@
|
||||||
*> -> the minimal requirement is LWORK >= 3*N.
|
*> -> the minimal requirement is LWORK >= 3*N.
|
||||||
*> -> For optimal performance,
|
*> -> For optimal performance,
|
||||||
*> LWORK >= max(N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,
|
*> LWORK >= max(N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,
|
||||||
*> where NB is the optimal block size for ZGEQP3, ZGEQRF, ZGELQ,
|
*> where NB is the optimal block size for ZGEQP3, ZGEQRF, ZGELQF,
|
||||||
*> ZUNMLQ. In general, the optimal length LWORK is computed as
|
*> ZUNMLQ. In general, the optimal length LWORK is computed as
|
||||||
*> LWORK >= max(N+LWORK(ZGEQP3), N+LWORK(ZGESVJ),
|
*> LWORK >= max(N+LWORK(ZGEQP3), N+LWORK(ZGESVJ),
|
||||||
*> N+LWORK(ZGELQF), 2*N+LWORK(ZGEQRF), N+LWORK(ZUNMLQ)).
|
*> N+LWORK(ZGELQF), 2*N+LWORK(ZGEQRF), N+LWORK(ZUNMLQ)).
|
||||||
|
@ -313,7 +313,7 @@
|
||||||
*> -> the minimal requirement is LWORK >= 3*N.
|
*> -> the minimal requirement is LWORK >= 3*N.
|
||||||
*> -> For optimal performance,
|
*> -> For optimal performance,
|
||||||
*> LWORK >= max(N+(N+1)*NB, 2*N,2*N+N*NB)=2*N+N*NB,
|
*> LWORK >= max(N+(N+1)*NB, 2*N,2*N+N*NB)=2*N+N*NB,
|
||||||
*> where NB is the optimal block size for ZGEQP3, ZGEQRF, ZGELQ,
|
*> where NB is the optimal block size for ZGEQP3, ZGEQRF, ZGELQF,
|
||||||
*> ZUNMLQ. In general, the optimal length LWORK is computed as
|
*> ZUNMLQ. In general, the optimal length LWORK is computed as
|
||||||
*> LWORK >= max(N+LWORK(ZGEQP3), LWORK(ZPOCON), N+LWORK(ZGESVJ),
|
*> LWORK >= max(N+LWORK(ZGEQP3), LWORK(ZPOCON), N+LWORK(ZGESVJ),
|
||||||
*> N+LWORK(ZGELQF), 2*N+LWORK(ZGEQRF), N+LWORK(ZUNMLQ)).
|
*> N+LWORK(ZGELQF), 2*N+LWORK(ZGEQRF), N+LWORK(ZUNMLQ)).
|
||||||
|
@ -349,7 +349,7 @@
|
||||||
*>
|
*>
|
||||||
*> \param[out] RWORK
|
*> \param[out] RWORK
|
||||||
*> \verbatim
|
*> \verbatim
|
||||||
*> RWORK is DOUBLE PRECISION array, dimension (MAX(7,LWORK))
|
*> RWORK is DOUBLE PRECISION array, dimension (MAX(7,LRWORK))
|
||||||
*> On exit,
|
*> On exit,
|
||||||
*> RWORK(1) = Determines the scaling factor SCALE = RWORK(2) / RWORK(1)
|
*> RWORK(1) = Determines the scaling factor SCALE = RWORK(2) / RWORK(1)
|
||||||
*> such that SCALE*SVA(1:N) are the computed singular values
|
*> such that SCALE*SVA(1:N) are the computed singular values
|
||||||
|
|
Loading…
Reference in New Issue