Update LAPACK to 3.9.0
This commit is contained in:
Martin Kroeker
GitHub
parent
ff45990663
commit
febeb9bcc1
|
|
@ -93,9 +93,9 @@
|
|||
*> dimension (LDA,N)
|
||||
*> On entry, the N-by-N coefficient matrix A.
|
||||
*> On exit, if iterative refinement has been successfully used
|
||||
*> (INFO.EQ.0 and ITER.GE.0, see description below), then A is
|
||||
*> (INFO = 0 and ITER >= 0, see description below), then A is
|
||||
*> unchanged, if double precision factorization has been used
|
||||
*> (INFO.EQ.0 and ITER.LT.0, see description below), then the
|
||||
*> (INFO = 0 and ITER < 0, see description below), then the
|
||||
*> array A contains the factors L and U from the factorization
|
||||
*> A = P*L*U; the unit diagonal elements of L are not stored.
|
||||
*> \endverbatim
|
||||
|
|
@ -112,8 +112,8 @@
|
|||
*> The pivot indices that define the permutation matrix P;
|
||||
*> row i of the matrix was interchanged with row IPIV(i).
|
||||
*> Corresponds either to the single precision factorization
|
||||
*> (if INFO.EQ.0 and ITER.GE.0) or the double precision
|
||||
*> factorization (if INFO.EQ.0 and ITER.LT.0).
|
||||
*> (if INFO = 0 and ITER >= 0) or the double precision
|
||||
*> factorization (if INFO = 0 and ITER < 0).
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] B
|
||||
|
|
@ -421,7 +421,7 @@
|
|||
30 CONTINUE
|
||||
*
|
||||
* If we are at this place of the code, this is because we have
|
||||
* performed ITER=ITERMAX iterations and never satisified the stopping
|
||||
* performed ITER=ITERMAX iterations and never satisfied the stopping
|
||||
* criterion, set up the ITER flag accordingly and follow up on double
|
||||
* precision routine.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -111,9 +111,9 @@
|
|||
*> elements need not be set and are assumed to be zero.
|
||||
*>
|
||||
*> On exit, if iterative refinement has been successfully used
|
||||
*> (INFO.EQ.0 and ITER.GE.0, see description below), then A is
|
||||
*> (INFO = 0 and ITER >= 0, see description below), then A is
|
||||
*> unchanged, if double precision factorization has been used
|
||||
*> (INFO.EQ.0 and ITER.LT.0, see description below), then the
|
||||
*> (INFO = 0 and ITER < 0, see description below), then the
|
||||
*> array A contains the factor U or L from the Cholesky
|
||||
*> factorization A = U**H*U or A = L*L**H.
|
||||
*> \endverbatim
|
||||
|
|
@ -431,7 +431,7 @@
|
|||
30 CONTINUE
|
||||
*
|
||||
* If we are at this place of the code, this is because we have
|
||||
* performed ITER=ITERMAX iterations and never satisified the
|
||||
* performed ITER=ITERMAX iterations and never satisfied the
|
||||
* stopping criterion, set up the ITER flag accordingly and follow
|
||||
* up on double precision routine.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@
|
|||
*> Specifies the form of the system of equations:
|
||||
*> = 'N': A * X = B (No transpose)
|
||||
*> = 'T': A**T * X = B (Transpose)
|
||||
*> = 'C': A**H * X = B (Conjugate transpose = Transpose)
|
||||
*> = 'C': A**H * X = B (Conjugate transpose)
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] EQUED
|
||||
|
|
@ -308,7 +308,7 @@
|
|||
*> information as described below. There currently are up to three
|
||||
*> pieces of information returned for each right-hand side. If
|
||||
*> componentwise accuracy is not requested (PARAMS(3) = 0.0), then
|
||||
*> ERR_BNDS_COMP is not accessed. If N_ERR_BNDS .LT. 3, then at most
|
||||
*> ERR_BNDS_COMP is not accessed. If N_ERR_BNDS < 3, then at most
|
||||
*> the first (:,N_ERR_BNDS) entries are returned.
|
||||
*>
|
||||
*> The first index in ERR_BNDS_COMP(i,:) corresponds to the ith
|
||||
|
|
@ -344,14 +344,14 @@
|
|||
*> \param[in] NPARAMS
|
||||
*> \verbatim
|
||||
*> NPARAMS is INTEGER
|
||||
*> Specifies the number of parameters set in PARAMS. If .LE. 0, the
|
||||
*> Specifies the number of parameters set in PARAMS. If <= 0, the
|
||||
*> PARAMS array is never referenced and default values are used.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in,out] PARAMS
|
||||
*> \verbatim
|
||||
*> PARAMS is DOUBLE PRECISION array, dimension NPARAMS
|
||||
*> Specifies algorithm parameters. If an entry is .LT. 0.0, then
|
||||
*> Specifies algorithm parameters. If an entry is < 0.0, then
|
||||
*> that entry will be filled with default value used for that
|
||||
*> parameter. Only positions up to NPARAMS are accessed; defaults
|
||||
*> are used for higher-numbered parameters.
|
||||
|
|
|
|||
|
|
@ -431,7 +431,7 @@
|
|||
*> information as described below. There currently are up to three
|
||||
*> pieces of information returned for each right-hand side. If
|
||||
*> componentwise accuracy is not requested (PARAMS(3) = 0.0), then
|
||||
*> ERR_BNDS_COMP is not accessed. If N_ERR_BNDS .LT. 3, then at most
|
||||
*> ERR_BNDS_COMP is not accessed. If N_ERR_BNDS < 3, then at most
|
||||
*> the first (:,N_ERR_BNDS) entries are returned.
|
||||
*>
|
||||
*> The first index in ERR_BNDS_COMP(i,:) corresponds to the ith
|
||||
|
|
@ -467,14 +467,14 @@
|
|||
*> \param[in] NPARAMS
|
||||
*> \verbatim
|
||||
*> NPARAMS is INTEGER
|
||||
*> Specifies the number of parameters set in PARAMS. If .LE. 0, the
|
||||
*> Specifies the number of parameters set in PARAMS. If <= 0, the
|
||||
*> PARAMS array is never referenced and default values are used.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in,out] PARAMS
|
||||
*> \verbatim
|
||||
*> PARAMS is DOUBLE PRECISION array, dimension NPARAMS
|
||||
*> Specifies algorithm parameters. If an entry is .LT. 0.0, then
|
||||
*> Specifies algorithm parameters. If an entry is < 0.0, then
|
||||
*> that entry will be filled with default value used for that
|
||||
*> parameter. Only positions up to NPARAMS are accessed; defaults
|
||||
*> are used for higher-numbered parameters.
|
||||
|
|
|
|||
|
|
@ -48,10 +48,10 @@
|
|||
*> \verbatim
|
||||
*> JOB is CHARACTER*1
|
||||
*> Specifies the type of backward transformation required:
|
||||
*> = 'N', do nothing, return immediately;
|
||||
*> = 'P', do backward transformation for permutation only;
|
||||
*> = 'S', do backward transformation for scaling only;
|
||||
*> = 'B', do backward transformations for both permutation and
|
||||
*> = 'N': do nothing, return immediately;
|
||||
*> = 'P': do backward transformation for permutation only;
|
||||
*> = 'S': do backward transformation for scaling only;
|
||||
*> = 'B': do backward transformations for both permutation and
|
||||
*> scaling.
|
||||
*> JOB must be the same as the argument JOB supplied to ZGEBAL.
|
||||
*> \endverbatim
|
||||
|
|
|
|||
|
|
@ -157,7 +157,7 @@
|
|||
*> < 0: if INFO = -i, the i-th argument had an illegal value.
|
||||
*> > 0: if INFO = i, the QR algorithm failed to compute all the
|
||||
*> eigenvalues, and no eigenvectors have been computed;
|
||||
*> elements and i+1:N of W contain eigenvalues which have
|
||||
*> elements i+1:N of W contain eigenvalues which have
|
||||
*> converged.
|
||||
*> \endverbatim
|
||||
*
|
||||
|
|
|
|||
|
|
@ -80,13 +80,13 @@
|
|||
*> desirable, then this option is advisable. The input matrix A
|
||||
*> is preprocessed with QR factorization with FULL (row and
|
||||
*> column) pivoting.
|
||||
*> = 'G' Computation as with 'F' with an additional estimate of the
|
||||
*> = 'G': Computation as with 'F' with an additional estimate of the
|
||||
*> condition number of B, where A=B*D. If A has heavily weighted
|
||||
*> rows, then using this condition number gives too pessimistic
|
||||
*> error bound.
|
||||
*> = 'A': Small singular values are not well determined by the data
|
||||
*> and are considered as noisy; the matrix is treated as
|
||||
*> numerically rank defficient. The error in the computed
|
||||
*> numerically rank deficient. The error in the computed
|
||||
*> singular values is bounded by f(m,n)*epsilon*||A||.
|
||||
*> The computed SVD A = U * S * V^* restores A up to
|
||||
*> f(m,n)*epsilon*||A||.
|
||||
|
|
@ -117,7 +117,7 @@
|
|||
*> = 'V': N columns of V are returned in the array V; Jacobi rotations
|
||||
*> are not explicitly accumulated.
|
||||
*> = 'J': N columns of V are returned in the array V, but they are
|
||||
*> computed as the product of Jacobi rotations, if JOBT .EQ. 'N'.
|
||||
*> computed as the product of Jacobi rotations, if JOBT = 'N'.
|
||||
*> = 'W': V may be used as workspace of length N*N. See the description
|
||||
*> of V.
|
||||
*> = 'N': V is not computed.
|
||||
|
|
@ -131,7 +131,7 @@
|
|||
*> specified range. If A .NE. 0 is scaled so that the largest singular
|
||||
*> value of c*A is around SQRT(BIG), BIG=DLAMCH('O'), then JOBR issues
|
||||
*> the licence to kill columns of A whose norm in c*A is less than
|
||||
*> SQRT(SFMIN) (for JOBR.EQ.'R'), or less than SMALL=SFMIN/EPSLN,
|
||||
*> SQRT(SFMIN) (for JOBR = 'R'), or less than SMALL=SFMIN/EPSLN,
|
||||
*> where SFMIN=DLAMCH('S'), EPSLN=DLAMCH('E').
|
||||
*> = 'N': Do not kill small columns of c*A. This option assumes that
|
||||
*> BLAS and QR factorizations and triangular solvers are
|
||||
|
|
@ -229,7 +229,7 @@
|
|||
*> If JOBU = 'F', then U contains on exit the M-by-M matrix of
|
||||
*> the left singular vectors, including an ONB
|
||||
*> of the orthogonal complement of the Range(A).
|
||||
*> If JOBU = 'W' .AND. (JOBV.EQ.'V' .AND. JOBT.EQ.'T' .AND. M.EQ.N),
|
||||
*> If JOBU = 'W' .AND. (JOBV = 'V' .AND. JOBT = 'T' .AND. M = N),
|
||||
*> then U is used as workspace if the procedure
|
||||
*> replaces A with A^*. In that case, [V] is computed
|
||||
*> in U as left singular vectors of A^* and then
|
||||
|
|
@ -251,7 +251,7 @@
|
|||
*> V is COMPLEX*16 array, dimension ( LDV, N )
|
||||
*> If JOBV = 'V', 'J' then V contains on exit the N-by-N matrix of
|
||||
*> the right singular vectors;
|
||||
*> If JOBV = 'W', AND (JOBU.EQ.'U' AND JOBT.EQ.'T' AND M.EQ.N),
|
||||
*> If JOBV = 'W', AND (JOBU = 'U' AND JOBT = 'T' AND M = N),
|
||||
*> then V is used as workspace if the pprocedure
|
||||
*> replaces A with A^*. In that case, [U] is computed
|
||||
*> in V as right singular vectors of A^* and then
|
||||
|
|
@ -282,7 +282,7 @@
|
|||
*> Length of CWORK to confirm proper allocation of workspace.
|
||||
*> LWORK depends on the job:
|
||||
*>
|
||||
*> 1. If only SIGMA is needed ( JOBU.EQ.'N', JOBV.EQ.'N' ) and
|
||||
*> 1. If only SIGMA is needed ( JOBU = 'N', JOBV = 'N' ) and
|
||||
*> 1.1 .. no scaled condition estimate required (JOBA.NE.'E'.AND.JOBA.NE.'G'):
|
||||
*> LWORK >= 2*N+1. This is the minimal requirement.
|
||||
*> ->> For optimal performance (blocked code) the optimal value
|
||||
|
|
@ -298,9 +298,9 @@
|
|||
*> In general, the optimal length LWORK is computed as
|
||||
*> LWORK >= max(N+LWORK(ZGEQP3),N+LWORK(ZGEQRF), LWORK(ZGESVJ),
|
||||
*> N*N+LWORK(ZPOCON)).
|
||||
*> 2. If SIGMA and the right singular vectors are needed (JOBV.EQ.'V'),
|
||||
*> (JOBU.EQ.'N')
|
||||
*> 2.1 .. no scaled condition estimate requested (JOBE.EQ.'N'):
|
||||
*> 2. If SIGMA and the right singular vectors are needed (JOBV = 'V'),
|
||||
*> (JOBU = 'N')
|
||||
*> 2.1 .. no scaled condition estimate requested (JOBE = 'N'):
|
||||
*> -> the minimal requirement is LWORK >= 3*N.
|
||||
*> -> For optimal performance,
|
||||
*> LWORK >= max(N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,
|
||||
|
|
@ -318,10 +318,10 @@
|
|||
*> LWORK >= max(N+LWORK(ZGEQP3), LWORK(ZPOCON), N+LWORK(ZGESVJ),
|
||||
*> N+LWORK(ZGELQF), 2*N+LWORK(ZGEQRF), N+LWORK(ZUNMLQ)).
|
||||
*> 3. If SIGMA and the left singular vectors are needed
|
||||
*> 3.1 .. no scaled condition estimate requested (JOBE.EQ.'N'):
|
||||
*> 3.1 .. no scaled condition estimate requested (JOBE = 'N'):
|
||||
*> -> the minimal requirement is LWORK >= 3*N.
|
||||
*> -> For optimal performance:
|
||||
*> if JOBU.EQ.'U' :: LWORK >= max(3*N, N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,
|
||||
*> if JOBU = 'U' :: LWORK >= max(3*N, N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,
|
||||
*> where NB is the optimal block size for ZGEQP3, ZGEQRF, ZUNMQR.
|
||||
*> In general, the optimal length LWORK is computed as
|
||||
*> LWORK >= max(N+LWORK(ZGEQP3), 2*N+LWORK(ZGEQRF), N+LWORK(ZUNMQR)).
|
||||
|
|
@ -329,15 +329,15 @@
|
|||
*> required (JOBA='E', or 'G').
|
||||
*> -> the minimal requirement is LWORK >= 3*N.
|
||||
*> -> For optimal performance:
|
||||
*> if JOBU.EQ.'U' :: LWORK >= max(3*N, N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,
|
||||
*> if JOBU = 'U' :: LWORK >= max(3*N, N+(N+1)*NB, 2*N+N*NB)=2*N+N*NB,
|
||||
*> where NB is the optimal block size for ZGEQP3, ZGEQRF, ZUNMQR.
|
||||
*> In general, the optimal length LWORK is computed as
|
||||
*> LWORK >= max(N+LWORK(ZGEQP3),N+LWORK(ZPOCON),
|
||||
*> 2*N+LWORK(ZGEQRF), N+LWORK(ZUNMQR)).
|
||||
*> 4. If the full SVD is needed: (JOBU.EQ.'U' or JOBU.EQ.'F') and
|
||||
*> 4.1. if JOBV.EQ.'V'
|
||||
*> 4. If the full SVD is needed: (JOBU = 'U' or JOBU = 'F') and
|
||||
*> 4.1. if JOBV = 'V'
|
||||
*> the minimal requirement is LWORK >= 5*N+2*N*N.
|
||||
*> 4.2. if JOBV.EQ.'J' the minimal requirement is
|
||||
*> 4.2. if JOBV = 'J' the minimal requirement is
|
||||
*> LWORK >= 4*N+N*N.
|
||||
*> In both cases, the allocated CWORK can accommodate blocked runs
|
||||
*> of ZGEQP3, ZGEQRF, ZGELQF, SUNMQR, ZUNMLQ.
|
||||
|
|
@ -356,7 +356,7 @@
|
|||
*> of A. (See the description of SVA().)
|
||||
*> RWORK(2) = See the description of RWORK(1).
|
||||
*> RWORK(3) = SCONDA is an estimate for the condition number of
|
||||
*> column equilibrated A. (If JOBA .EQ. 'E' or 'G')
|
||||
*> column equilibrated A. (If JOBA = 'E' or 'G')
|
||||
*> SCONDA is an estimate of SQRT(||(R^* * R)^(-1)||_1).
|
||||
*> It is computed using SPOCON. It holds
|
||||
*> N^(-1/4) * SCONDA <= ||R^(-1)||_2 <= N^(1/4) * SCONDA
|
||||
|
|
@ -375,7 +375,7 @@
|
|||
*> triangular factor in the first QR factorization.
|
||||
*> RWORK(5) = an estimate of the scaled condition number of the
|
||||
*> triangular factor in the second QR factorization.
|
||||
*> The following two parameters are computed if JOBT .EQ. 'T'.
|
||||
*> The following two parameters are computed if JOBT = 'T'.
|
||||
*> They are provided for a developer/implementer who is familiar
|
||||
*> with the details of the method.
|
||||
*> RWORK(6) = the entropy of A^* * A :: this is the Shannon entropy
|
||||
|
|
@ -456,13 +456,13 @@
|
|||
*> of JOBA and JOBR.
|
||||
*> IWORK(2) = the number of the computed nonzero singular values
|
||||
*> IWORK(3) = if nonzero, a warning message:
|
||||
*> If IWORK(3).EQ.1 then some of the column norms of A
|
||||
*> If IWORK(3) = 1 then some of the column norms of A
|
||||
*> were denormalized floats. The requested high accuracy
|
||||
*> is not warranted by the data.
|
||||
*> IWORK(4) = 1 or -1. If IWORK(4) .EQ. 1, then the procedure used A^* to
|
||||
*> IWORK(4) = 1 or -1. If IWORK(4) = 1, then the procedure used A^* to
|
||||
*> do the job as specified by the JOB parameters.
|
||||
*> If the call to ZGEJSV is a workspace query (indicated by LWORK .EQ. -1 or
|
||||
*> LRWORK .EQ. -1), then on exit IWORK(1) contains the required length of
|
||||
*> If the call to ZGEJSV is a workspace query (indicated by LWORK = -1 or
|
||||
*> LRWORK = -1), then on exit IWORK(1) contains the required length of
|
||||
*> IWORK for the job parameters used in the call.
|
||||
*> \endverbatim
|
||||
*>
|
||||
|
|
@ -1338,7 +1338,7 @@
|
|||
IF ( L2ABER ) THEN
|
||||
* Standard absolute error bound suffices. All sigma_i with
|
||||
* sigma_i < N*EPSLN*||A|| are flushed to zero. This is an
|
||||
* agressive enforcement of lower numerical rank by introducing a
|
||||
* aggressive enforcement of lower numerical rank by introducing a
|
||||
* backward error of the order of N*EPSLN*||A||.
|
||||
TEMP1 = SQRT(DBLE(N))*EPSLN
|
||||
DO 3001 p = 2, N
|
||||
|
|
@ -1350,7 +1350,7 @@
|
|||
3001 CONTINUE
|
||||
3002 CONTINUE
|
||||
ELSE IF ( L2RANK ) THEN
|
||||
* .. similarly as above, only slightly more gentle (less agressive).
|
||||
* .. similarly as above, only slightly more gentle (less aggressive).
|
||||
* Sudden drop on the diagonal of R1 is used as the criterion for
|
||||
* close-to-rank-deficient.
|
||||
TEMP1 = SQRT(SFMIN)
|
||||
|
|
@ -1720,7 +1720,7 @@
|
|||
CALL ZPOCON('L',NR,CWORK(2*N+1),NR,ONE,TEMP1,
|
||||
$ CWORK(2*N+NR*NR+1),RWORK,IERR)
|
||||
CONDR1 = ONE / SQRT(TEMP1)
|
||||
* .. here need a second oppinion on the condition number
|
||||
* .. here need a second opinion on the condition number
|
||||
* .. then assume worst case scenario
|
||||
* R1 is OK for inverse <=> CONDR1 .LT. DBLE(N)
|
||||
* more conservative <=> CONDR1 .LT. SQRT(DBLE(N))
|
||||
|
|
@ -1765,7 +1765,7 @@
|
|||
ELSE
|
||||
*
|
||||
* .. ill-conditioned case: second QRF with pivoting
|
||||
* Note that windowed pivoting would be equaly good
|
||||
* Note that windowed pivoting would be equally good
|
||||
* numerically, and more run-time efficient. So, in
|
||||
* an optimal implementation, the next call to ZGEQP3
|
||||
* should be replaced with eg. CALL ZGEQPX (ACM TOMS #782)
|
||||
|
|
@ -1823,7 +1823,7 @@
|
|||
*
|
||||
IF ( CONDR2 .GE. COND_OK ) THEN
|
||||
* .. save the Householder vectors used for Q3
|
||||
* (this overwrittes the copy of R2, as it will not be
|
||||
* (this overwrites the copy of R2, as it will not be
|
||||
* needed in this branch, but it does not overwritte the
|
||||
* Huseholder vectors of Q2.).
|
||||
CALL ZLACPY( 'U', NR, NR, V, LDV, CWORK(2*N+1), N )
|
||||
|
|
@ -2079,7 +2079,7 @@
|
|||
*
|
||||
* This branch deploys a preconditioned Jacobi SVD with explicitly
|
||||
* accumulated rotations. It is included as optional, mainly for
|
||||
* experimental purposes. It does perfom well, and can also be used.
|
||||
* experimental purposes. It does perform well, and can also be used.
|
||||
* In this implementation, this branch will be automatically activated
|
||||
* if the condition number sigma_max(A) / sigma_min(A) is predicted
|
||||
* to be greater than the overflow threshold. This is because the
|
||||
|
|
|
|||
|
|
@ -1,3 +1,4 @@
|
|||
*> \brief \b ZGELQ
|
||||
*
|
||||
* Definition:
|
||||
* ===========
|
||||
|
|
@ -17,7 +18,17 @@
|
|||
* =============
|
||||
*>
|
||||
*> \verbatim
|
||||
*> ZGELQ computes a LQ factorization of an M-by-N matrix A.
|
||||
*>
|
||||
*> ZGELQ computes an LQ factorization of a complex M-by-N matrix A:
|
||||
*>
|
||||
*> A = ( L 0 ) * Q
|
||||
*>
|
||||
*> where:
|
||||
*>
|
||||
*> Q is a N-by-N orthogonal matrix;
|
||||
*> L is an lower-triangular M-by-M matrix;
|
||||
*> 0 is a M-by-(N-M) zero matrix, if M < N.
|
||||
*>
|
||||
*> \endverbatim
|
||||
*
|
||||
* Arguments:
|
||||
|
|
@ -138,7 +149,7 @@
|
|||
*> \verbatim
|
||||
*>
|
||||
*> These details are particular for this LAPACK implementation. Users should not
|
||||
*> take them for granted. These details may change in the future, and are unlikely not
|
||||
*> take them for granted. These details may change in the future, and are not likely
|
||||
*> true for another LAPACK implementation. These details are relevant if one wants
|
||||
*> to try to understand the code. They are not part of the interface.
|
||||
*>
|
||||
|
|
@ -159,10 +170,10 @@
|
|||
SUBROUTINE ZGELQ( M, N, A, LDA, T, TSIZE, WORK, LWORK,
|
||||
$ INFO )
|
||||
*
|
||||
* -- LAPACK computational routine (version 3.7.0) --
|
||||
* -- LAPACK computational routine (version 3.9.0) --
|
||||
* -- LAPACK is a software package provided by Univ. of Tennessee, --
|
||||
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd. --
|
||||
* December 2016
|
||||
* November 2019
|
||||
*
|
||||
* .. Scalar Arguments ..
|
||||
INTEGER INFO, LDA, M, N, TSIZE, LWORK
|
||||
|
|
|
|||
|
|
@ -33,8 +33,16 @@
|
|||
*>
|
||||
*> \verbatim
|
||||
*>
|
||||
*> ZGELQ2 computes an LQ factorization of a complex m by n matrix A:
|
||||
*> A = L * Q.
|
||||
*> ZGELQ2 computes an LQ factorization of a complex m-by-n matrix A:
|
||||
*>
|
||||
*> A = ( L 0 ) * Q
|
||||
*>
|
||||
*> where:
|
||||
*>
|
||||
*> Q is a n-by-n orthogonal matrix;
|
||||
*> L is an lower-triangular m-by-m matrix;
|
||||
*> 0 is a m-by-(n-m) zero matrix, if m < n.
|
||||
*>
|
||||
*> \endverbatim
|
||||
*
|
||||
* Arguments:
|
||||
|
|
@ -96,7 +104,7 @@
|
|||
*> \author Univ. of Colorado Denver
|
||||
*> \author NAG Ltd.
|
||||
*
|
||||
*> \date December 2016
|
||||
*> \date November 2019
|
||||
*
|
||||
*> \ingroup complex16GEcomputational
|
||||
*
|
||||
|
|
@ -121,10 +129,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE ZGELQ2( M, N, A, LDA, TAU, WORK, INFO )
|
||||
*
|
||||
* -- LAPACK computational routine (version 3.7.0) --
|
||||
* -- LAPACK computational routine (version 3.9.0) --
|
||||
* -- LAPACK is a software package provided by Univ. of Tennessee, --
|
||||
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
|
||||
* December 2016
|
||||
* November 2019
|
||||
*
|
||||
* .. Scalar Arguments ..
|
||||
INTEGER INFO, LDA, M, N
|
||||
|
|
|
|||
|
|
@ -34,7 +34,15 @@
|
|||
*> \verbatim
|
||||
*>
|
||||
*> ZGELQF computes an LQ factorization of a complex M-by-N matrix A:
|
||||
*> A = L * Q.
|
||||
*>
|
||||
*> A = ( L 0 ) * Q
|
||||
*>
|
||||
*> where:
|
||||
*>
|
||||
*> Q is a N-by-N orthogonal matrix;
|
||||
*> L is an lower-triangular M-by-M matrix;
|
||||
*> 0 is a M-by-(N-M) zero matrix, if M < N.
|
||||
*>
|
||||
*> \endverbatim
|
||||
*
|
||||
* Arguments:
|
||||
|
|
@ -110,7 +118,7 @@
|
|||
*> \author Univ. of Colorado Denver
|
||||
*> \author NAG Ltd.
|
||||
*
|
||||
*> \date December 2016
|
||||
*> \date November 2019
|
||||
*
|
||||
*> \ingroup complex16GEcomputational
|
||||
*
|
||||
|
|
@ -135,10 +143,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE ZGELQF( M, N, A, LDA, TAU, WORK, LWORK, INFO )
|
||||
*
|
||||
* -- LAPACK computational routine (version 3.7.0) --
|
||||
* -- LAPACK computational routine (version 3.9.0) --
|
||||
* -- LAPACK is a software package provided by Univ. of Tennessee, --
|
||||
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
|
||||
* December 2016
|
||||
* November 2019
|
||||
*
|
||||
* .. Scalar Arguments ..
|
||||
INTEGER INFO, LDA, LWORK, M, N
|
||||
|
|
|
|||
|
|
@ -1,3 +1,4 @@
|
|||
*> \brief \b ZGEMLQ
|
||||
*
|
||||
* Definition:
|
||||
* ===========
|
||||
|
|
@ -142,7 +143,7 @@
|
|||
*> \verbatim
|
||||
*>
|
||||
*> These details are particular for this LAPACK implementation. Users should not
|
||||
*> take them for granted. These details may change in the future, and are unlikely not
|
||||
*> take them for granted. These details may change in the future, and are not likely
|
||||
*> true for another LAPACK implementation. These details are relevant if one wants
|
||||
*> to try to understand the code. They are not part of the interface.
|
||||
*>
|
||||
|
|
|
|||
|
|
@ -1,3 +1,4 @@
|
|||
*> \brief \b ZGEMQR
|
||||
*
|
||||
* Definition:
|
||||
* ===========
|
||||
|
|
@ -144,7 +145,7 @@
|
|||
*> \verbatim
|
||||
*>
|
||||
*> These details are particular for this LAPACK implementation. Users should not
|
||||
*> take them for granted. These details may change in the future, and are unlikely not
|
||||
*> take them for granted. These details may change in the future, and are not likely
|
||||
*> true for another LAPACK implementation. These details are relevant if one wants
|
||||
*> to try to understand the code. They are not part of the interface.
|
||||
*>
|
||||
|
|
|
|||
|
|
@ -1,3 +1,4 @@
|
|||
*> \brief \b ZGEQR
|
||||
*
|
||||
* Definition:
|
||||
* ===========
|
||||
|
|
@ -17,7 +18,18 @@
|
|||
* =============
|
||||
*>
|
||||
*> \verbatim
|
||||
*> ZGEQR computes a QR factorization of an M-by-N matrix A.
|
||||
*>
|
||||
*> ZGEQR computes a QR factorization of a complex M-by-N matrix A:
|
||||
*>
|
||||
*> A = Q * ( R ),
|
||||
*> ( 0 )
|
||||
*>
|
||||
*> where:
|
||||
*>
|
||||
*> Q is a M-by-M orthogonal matrix;
|
||||
*> R is an upper-triangular N-by-N matrix;
|
||||
*> 0 is a (M-N)-by-N zero matrix, if M > N.
|
||||
*>
|
||||
*> \endverbatim
|
||||
*
|
||||
* Arguments:
|
||||
|
|
@ -138,7 +150,7 @@
|
|||
*> \verbatim
|
||||
*>
|
||||
*> These details are particular for this LAPACK implementation. Users should not
|
||||
*> take them for granted. These details may change in the future, and are unlikely not
|
||||
*> take them for granted. These details may change in the future, and are not likely
|
||||
*> true for another LAPACK implementation. These details are relevant if one wants
|
||||
*> to try to understand the code. They are not part of the interface.
|
||||
*>
|
||||
|
|
@ -160,10 +172,10 @@
|
|||
SUBROUTINE ZGEQR( M, N, A, LDA, T, TSIZE, WORK, LWORK,
|
||||
$ INFO )
|
||||
*
|
||||
* -- LAPACK computational routine (version 3.7.0) --
|
||||
* -- LAPACK computational routine (version 3.9.0) --
|
||||
* -- LAPACK is a software package provided by Univ. of Tennessee, --
|
||||
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd. --
|
||||
* December 2016
|
||||
* November 2019
|
||||
*
|
||||
* .. Scalar Arguments ..
|
||||
INTEGER INFO, LDA, M, N, TSIZE, LWORK
|
||||
|
|
|
|||
|
|
@ -33,8 +33,17 @@
|
|||
*>
|
||||
*> \verbatim
|
||||
*>
|
||||
*> ZGEQR2 computes a QR factorization of a complex m by n matrix A:
|
||||
*> A = Q * R.
|
||||
*> ZGEQR2 computes a QR factorization of a complex m-by-n matrix A:
|
||||
*>
|
||||
*> A = Q * ( R ),
|
||||
*> ( 0 )
|
||||
*>
|
||||
*> where:
|
||||
*>
|
||||
*> Q is a m-by-m orthogonal matrix;
|
||||
*> R is an upper-triangular n-by-n matrix;
|
||||
*> 0 is a (m-n)-by-n zero matrix, if m > n.
|
||||
*>
|
||||
*> \endverbatim
|
||||
*
|
||||
* Arguments:
|
||||
|
|
@ -96,7 +105,7 @@
|
|||
*> \author Univ. of Colorado Denver
|
||||
*> \author NAG Ltd.
|
||||
*
|
||||
*> \date December 2016
|
||||
*> \date November 2019
|
||||
*
|
||||
*> \ingroup complex16GEcomputational
|
||||
*
|
||||
|
|
@ -121,10 +130,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE ZGEQR2( M, N, A, LDA, TAU, WORK, INFO )
|
||||
*
|
||||
* -- LAPACK computational routine (version 3.7.0) --
|
||||
* -- LAPACK computational routine (version 3.9.0) --
|
||||
* -- LAPACK is a software package provided by Univ. of Tennessee, --
|
||||
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
|
||||
* December 2016
|
||||
* November 2019
|
||||
*
|
||||
* .. Scalar Arguments ..
|
||||
INTEGER INFO, LDA, M, N
|
||||
|
|
|
|||
|
|
@ -33,8 +33,18 @@
|
|||
*>
|
||||
*> \verbatim
|
||||
*>
|
||||
*> ZGEQR2P computes a QR factorization of a complex m by n matrix A:
|
||||
*> A = Q * R. The diagonal entries of R are real and nonnegative.
|
||||
*> ZGEQR2P computes a QR factorization of a complex m-by-n matrix A:
|
||||
*>
|
||||
*> A = Q * ( R ),
|
||||
*> ( 0 )
|
||||
*>
|
||||
*> where:
|
||||
*>
|
||||
*> Q is a m-by-m orthogonal matrix;
|
||||
*> R is an upper-triangular n-by-n matrix with nonnegative diagonal
|
||||
*> entries;
|
||||
*> 0 is a (m-n)-by-n zero matrix, if m > n.
|
||||
*>
|
||||
*> \endverbatim
|
||||
*
|
||||
* Arguments:
|
||||
|
|
@ -97,7 +107,7 @@
|
|||
*> \author Univ. of Colorado Denver
|
||||
*> \author NAG Ltd.
|
||||
*
|
||||
*> \date December 2016
|
||||
*> \date November 2019
|
||||
*
|
||||
*> \ingroup complex16GEcomputational
|
||||
*
|
||||
|
|
@ -124,10 +134,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE ZGEQR2P( M, N, A, LDA, TAU, WORK, INFO )
|
||||
*
|
||||
* -- LAPACK computational routine (version 3.7.0) --
|
||||
* -- LAPACK computational routine (version 3.9.0) --
|
||||
* -- LAPACK is a software package provided by Univ. of Tennessee, --
|
||||
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
|
||||
* December 2016
|
||||
* November 2019
|
||||
*
|
||||
* .. Scalar Arguments ..
|
||||
INTEGER INFO, LDA, M, N
|
||||
|
|
|
|||
|
|
@ -34,7 +34,16 @@
|
|||
*> \verbatim
|
||||
*>
|
||||
*> ZGEQRF computes a QR factorization of a complex M-by-N matrix A:
|
||||
*> A = Q * R.
|
||||
*>
|
||||
*> A = Q * ( R ),
|
||||
*> ( 0 )
|
||||
*>
|
||||
*> where:
|
||||
*>
|
||||
*> Q is a M-by-M orthogonal matrix;
|
||||
*> R is an upper-triangular N-by-N matrix;
|
||||
*> 0 is a (M-N)-by-N zero matrix, if M > N.
|
||||
*>
|
||||
*> \endverbatim
|
||||
*
|
||||
* Arguments:
|
||||
|
|
@ -111,7 +120,7 @@
|
|||
*> \author Univ. of Colorado Denver
|
||||
*> \author NAG Ltd.
|
||||
*
|
||||
*> \date December 2016
|
||||
*> \date November 2019
|
||||
*
|
||||
*> \ingroup complex16GEcomputational
|
||||
*
|
||||
|
|
@ -136,10 +145,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE ZGEQRF( M, N, A, LDA, TAU, WORK, LWORK, INFO )
|
||||
*
|
||||
* -- LAPACK computational routine (version 3.7.0) --
|
||||
* -- LAPACK computational routine (version 3.9.0) --
|
||||
* -- LAPACK is a software package provided by Univ. of Tennessee, --
|
||||
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
|
||||
* December 2016
|
||||
* November 2019
|
||||
*
|
||||
* .. Scalar Arguments ..
|
||||
INTEGER INFO, LDA, LWORK, M, N
|
||||
|
|
|
|||
|
|
@ -33,8 +33,18 @@
|
|||
*>
|
||||
*> \verbatim
|
||||
*>
|
||||
*> ZGEQRFP computes a QR factorization of a complex M-by-N matrix A:
|
||||
*> A = Q * R. The diagonal entries of R are real and nonnegative.
|
||||
*> ZGEQR2P computes a QR factorization of a complex M-by-N matrix A:
|
||||
*>
|
||||
*> A = Q * ( R ),
|
||||
*> ( 0 )
|
||||
*>
|
||||
*> where:
|
||||
*>
|
||||
*> Q is a M-by-M orthogonal matrix;
|
||||
*> R is an upper-triangular N-by-N matrix with nonnegative diagonal
|
||||
*> entries;
|
||||
*> 0 is a (M-N)-by-N zero matrix, if M > N.
|
||||
*>
|
||||
*> \endverbatim
|
||||
*
|
||||
* Arguments:
|
||||
|
|
@ -112,7 +122,7 @@
|
|||
*> \author Univ. of Colorado Denver
|
||||
*> \author NAG Ltd.
|
||||
*
|
||||
*> \date December 2016
|
||||
*> \date November 2019
|
||||
*
|
||||
*> \ingroup complex16GEcomputational
|
||||
*
|
||||
|
|
@ -139,10 +149,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE ZGEQRFP( M, N, A, LDA, TAU, WORK, LWORK, INFO )
|
||||
*
|
||||
* -- LAPACK computational routine (version 3.7.0) --
|
||||
* -- LAPACK computational routine (version 3.9.0) --
|
||||
* -- LAPACK is a software package provided by Univ. of Tennessee, --
|
||||
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
|
||||
* December 2016
|
||||
* November 2019
|
||||
*
|
||||
* .. Scalar Arguments ..
|
||||
INTEGER INFO, LDA, LWORK, M, N
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@
|
|||
*> Specifies the form of the system of equations:
|
||||
*> = 'N': A * X = B (No transpose)
|
||||
*> = 'T': A**T * X = B (Transpose)
|
||||
*> = 'C': A**H * X = B (Conjugate transpose = Transpose)
|
||||
*> = 'C': A**H * X = B (Conjugate transpose)
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] EQUED
|
||||
|
|
@ -283,7 +283,7 @@
|
|||
*> information as described below. There currently are up to three
|
||||
*> pieces of information returned for each right-hand side. If
|
||||
*> componentwise accuracy is not requested (PARAMS(3) = 0.0), then
|
||||
*> ERR_BNDS_COMP is not accessed. If N_ERR_BNDS .LT. 3, then at most
|
||||
*> ERR_BNDS_COMP is not accessed. If N_ERR_BNDS < 3, then at most
|
||||
*> the first (:,N_ERR_BNDS) entries are returned.
|
||||
*>
|
||||
*> The first index in ERR_BNDS_COMP(i,:) corresponds to the ith
|
||||
|
|
@ -319,14 +319,14 @@
|
|||
*> \param[in] NPARAMS
|
||||
*> \verbatim
|
||||
*> NPARAMS is INTEGER
|
||||
*> Specifies the number of parameters set in PARAMS. If .LE. 0, the
|
||||
*> Specifies the number of parameters set in PARAMS. If <= 0, the
|
||||
*> PARAMS array is never referenced and default values are used.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in,out] PARAMS
|
||||
*> \verbatim
|
||||
*> PARAMS is DOUBLE PRECISION array, dimension NPARAMS
|
||||
*> Specifies algorithm parameters. If an entry is .LT. 0.0, then
|
||||
*> Specifies algorithm parameters. If an entry is < 0.0, then
|
||||
*> that entry will be filled with default value used for that
|
||||
*> parameter. Only positions up to NPARAMS are accessed; defaults
|
||||
*> are used for higher-numbered parameters.
|
||||
|
|
|
|||
|
|
@ -91,7 +91,7 @@
|
|||
*> \verbatim
|
||||
*> SCALE is DOUBLE PRECISION
|
||||
*> On exit, SCALE contains the scale factor. SCALE is chosen
|
||||
*> 0 <= SCALE <= 1 to prevent owerflow in the solution.
|
||||
*> 0 <= SCALE <= 1 to prevent overflow in the solution.
|
||||
*> \endverbatim
|
||||
*
|
||||
* Authors:
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -18,7 +18,7 @@
|
|||
* Definition:
|
||||
* ===========
|
||||
*
|
||||
* SUBROUTINE CGESVDX( JOBU, JOBVT, RANGE, M, N, A, LDA, VL, VU,
|
||||
* SUBROUTINE ZGESVDX( JOBU, JOBVT, RANGE, M, N, A, LDA, VL, VU,
|
||||
* $ IL, IU, NS, S, U, LDU, VT, LDVT, WORK,
|
||||
* $ LWORK, RWORK, IWORK, INFO )
|
||||
*
|
||||
|
|
|
|||
|
|
@ -116,8 +116,8 @@
|
|||
*> A is COMPLEX*16 array, dimension (LDA,N)
|
||||
*> On entry, the M-by-N matrix A.
|
||||
*> On exit,
|
||||
*> If JOBU .EQ. 'U' .OR. JOBU .EQ. 'C':
|
||||
*> If INFO .EQ. 0 :
|
||||
*> If JOBU = 'U' .OR. JOBU = 'C':
|
||||
*> If INFO = 0 :
|
||||
*> RANKA orthonormal columns of U are returned in the
|
||||
*> leading RANKA columns of the array A. Here RANKA <= N
|
||||
*> is the number of computed singular values of A that are
|
||||
|
|
@ -127,9 +127,9 @@
|
|||
*> in the array RWORK as RANKA=NINT(RWORK(2)). Also see the
|
||||
*> descriptions of SVA and RWORK. The computed columns of U
|
||||
*> are mutually numerically orthogonal up to approximately
|
||||
*> TOL=SQRT(M)*EPS (default); or TOL=CTOL*EPS (JOBU.EQ.'C'),
|
||||
*> TOL=SQRT(M)*EPS (default); or TOL=CTOL*EPS (JOBU = 'C'),
|
||||
*> see the description of JOBU.
|
||||
*> If INFO .GT. 0,
|
||||
*> If INFO > 0,
|
||||
*> the procedure ZGESVJ did not converge in the given number
|
||||
*> of iterations (sweeps). In that case, the computed
|
||||
*> columns of U may not be orthogonal up to TOL. The output
|
||||
|
|
@ -137,8 +137,8 @@
|
|||
*> values in SVA(1:N)) and V is still a decomposition of the
|
||||
*> input matrix A in the sense that the residual
|
||||
*> || A - SCALE * U * SIGMA * V^* ||_2 / ||A||_2 is small.
|
||||
*> If JOBU .EQ. 'N':
|
||||
*> If INFO .EQ. 0 :
|
||||
*> If JOBU = 'N':
|
||||
*> If INFO = 0 :
|
||||
*> Note that the left singular vectors are 'for free' in the
|
||||
*> one-sided Jacobi SVD algorithm. However, if only the
|
||||
*> singular values are needed, the level of numerical
|
||||
|
|
@ -147,7 +147,7 @@
|
|||
*> numerically orthogonal up to approximately M*EPS. Thus,
|
||||
*> on exit, A contains the columns of U scaled with the
|
||||
*> corresponding singular values.
|
||||
*> If INFO .GT. 0 :
|
||||
*> If INFO > 0:
|
||||
*> the procedure ZGESVJ did not converge in the given number
|
||||
*> of iterations (sweeps).
|
||||
*> \endverbatim
|
||||
|
|
@ -162,9 +162,9 @@
|
|||
*> \verbatim
|
||||
*> SVA is DOUBLE PRECISION array, dimension (N)
|
||||
*> On exit,
|
||||
*> If INFO .EQ. 0 :
|
||||
*> If INFO = 0 :
|
||||
*> depending on the value SCALE = RWORK(1), we have:
|
||||
*> If SCALE .EQ. ONE:
|
||||
*> If SCALE = ONE:
|
||||
*> SVA(1:N) contains the computed singular values of A.
|
||||
*> During the computation SVA contains the Euclidean column
|
||||
*> norms of the iterated matrices in the array A.
|
||||
|
|
@ -173,7 +173,7 @@
|
|||
*> factored representation is due to the fact that some of the
|
||||
*> singular values of A might underflow or overflow.
|
||||
*>
|
||||
*> If INFO .GT. 0 :
|
||||
*> If INFO > 0:
|
||||
*> the procedure ZGESVJ did not converge in the given number of
|
||||
*> iterations (sweeps) and SCALE*SVA(1:N) may not be accurate.
|
||||
*> \endverbatim
|
||||
|
|
@ -181,7 +181,7 @@
|
|||
*> \param[in] MV
|
||||
*> \verbatim
|
||||
*> MV is INTEGER
|
||||
*> If JOBV .EQ. 'A', then the product of Jacobi rotations in ZGESVJ
|
||||
*> If JOBV = 'A', then the product of Jacobi rotations in ZGESVJ
|
||||
*> is applied to the first MV rows of V. See the description of JOBV.
|
||||
*> \endverbatim
|
||||
*>
|
||||
|
|
@ -199,16 +199,16 @@
|
|||
*> \param[in] LDV
|
||||
*> \verbatim
|
||||
*> LDV is INTEGER
|
||||
*> The leading dimension of the array V, LDV .GE. 1.
|
||||
*> If JOBV .EQ. 'V', then LDV .GE. max(1,N).
|
||||
*> If JOBV .EQ. 'A', then LDV .GE. max(1,MV) .
|
||||
*> The leading dimension of the array V, LDV >= 1.
|
||||
*> If JOBV = 'V', then LDV >= max(1,N).
|
||||
*> If JOBV = 'A', then LDV >= max(1,MV) .
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in,out] CWORK
|
||||
*> \verbatim
|
||||
*> CWORK is COMPLEX*16 array, dimension (max(1,LWORK))
|
||||
*> Used as workspace.
|
||||
*> If on entry LWORK .EQ. -1, then a workspace query is assumed and
|
||||
*> If on entry LWORK = -1, then a workspace query is assumed and
|
||||
*> no computation is done; CWORK(1) is set to the minial (and optimal)
|
||||
*> length of CWORK.
|
||||
*> \endverbatim
|
||||
|
|
@ -223,7 +223,7 @@
|
|||
*> \verbatim
|
||||
*> RWORK is DOUBLE PRECISION array, dimension (max(6,LRWORK))
|
||||
*> On entry,
|
||||
*> If JOBU .EQ. 'C' :
|
||||
*> If JOBU = 'C' :
|
||||
*> RWORK(1) = CTOL, where CTOL defines the threshold for convergence.
|
||||
*> The process stops if all columns of A are mutually
|
||||
*> orthogonal up to CTOL*EPS, EPS=DLAMCH('E').
|
||||
|
|
@ -243,11 +243,11 @@
|
|||
*> RWORK(5) = max_{i.NE.j} |COS(A(:,i),A(:,j))| in the last sweep.
|
||||
*> This is useful information in cases when ZGESVJ did
|
||||
*> not converge, as it can be used to estimate whether
|
||||
*> the output is stil useful and for post festum analysis.
|
||||
*> the output is still useful and for post festum analysis.
|
||||
*> RWORK(6) = the largest absolute value over all sines of the
|
||||
*> Jacobi rotation angles in the last sweep. It can be
|
||||
*> useful for a post festum analysis.
|
||||
*> If on entry LRWORK .EQ. -1, then a workspace query is assumed and
|
||||
*> If on entry LRWORK = -1, then a workspace query is assumed and
|
||||
*> no computation is done; RWORK(1) is set to the minial (and optimal)
|
||||
*> length of RWORK.
|
||||
*> \endverbatim
|
||||
|
|
|
|||
|
|
@ -411,7 +411,7 @@
|
|||
*> information as described below. There currently are up to three
|
||||
*> pieces of information returned for each right-hand side. If
|
||||
*> componentwise accuracy is not requested (PARAMS(3) = 0.0), then
|
||||
*> ERR_BNDS_COMP is not accessed. If N_ERR_BNDS .LT. 3, then at most
|
||||
*> ERR_BNDS_COMP is not accessed. If N_ERR_BNDS < 3, then at most
|
||||
*> the first (:,N_ERR_BNDS) entries are returned.
|
||||
*>
|
||||
*> The first index in ERR_BNDS_COMP(i,:) corresponds to the ith
|
||||
|
|
@ -447,14 +447,14 @@
|
|||
*> \param[in] NPARAMS
|
||||
*> \verbatim
|
||||
*> NPARAMS is INTEGER
|
||||
*> Specifies the number of parameters set in PARAMS. If .LE. 0, the
|
||||
*> Specifies the number of parameters set in PARAMS. If <= 0, the
|
||||
*> PARAMS array is never referenced and default values are used.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in,out] PARAMS
|
||||
*> \verbatim
|
||||
*> PARAMS is DOUBLE PRECISION array, dimension NPARAMS
|
||||
*> Specifies algorithm parameters. If an entry is .LT. 0.0, then
|
||||
*> Specifies algorithm parameters. If an entry is < 0.0, then
|
||||
*> that entry will be filled with default value used for that
|
||||
*> parameter. Only positions up to NPARAMS are accessed; defaults
|
||||
*> are used for higher-numbered parameters.
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
*> \brief \b ZGETSLS
|
||||
*
|
||||
* Definition:
|
||||
* ===========
|
||||
*
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@
|
|||
*> \param[in] MV
|
||||
*> \verbatim
|
||||
*> MV is INTEGER
|
||||
*> If JOBV .EQ. 'A', then MV rows of V are post-multipled by a
|
||||
*> If JOBV = 'A', then MV rows of V are post-multipled by a
|
||||
*> sequence of Jacobi rotations.
|
||||
*> If JOBV = 'N', then MV is not referenced.
|
||||
*> \endverbatim
|
||||
|
|
@ -125,9 +125,9 @@
|
|||
*> \param[in,out] V
|
||||
*> \verbatim
|
||||
*> V is COMPLEX*16 array, dimension (LDV,N)
|
||||
*> If JOBV .EQ. 'V' then N rows of V are post-multipled by a
|
||||
*> If JOBV = 'V' then N rows of V are post-multipled by a
|
||||
*> sequence of Jacobi rotations.
|
||||
*> If JOBV .EQ. 'A' then MV rows of V are post-multipled by a
|
||||
*> If JOBV = 'A' then MV rows of V are post-multipled by a
|
||||
*> sequence of Jacobi rotations.
|
||||
*> If JOBV = 'N', then V is not referenced.
|
||||
*> \endverbatim
|
||||
|
|
@ -136,8 +136,8 @@
|
|||
*> \verbatim
|
||||
*> LDV is INTEGER
|
||||
*> The leading dimension of the array V, LDV >= 1.
|
||||
*> If JOBV = 'V', LDV .GE. N.
|
||||
*> If JOBV = 'A', LDV .GE. MV.
|
||||
*> If JOBV = 'V', LDV >= N.
|
||||
*> If JOBV = 'A', LDV >= MV.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] EPS
|
||||
|
|
@ -157,7 +157,7 @@
|
|||
*> TOL is DOUBLE PRECISION
|
||||
*> TOL is the threshold for Jacobi rotations. For a pair
|
||||
*> A(:,p), A(:,q) of pivot columns, the Jacobi rotation is
|
||||
*> applied only if ABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL.
|
||||
*> applied only if ABS(COS(angle(A(:,p),A(:,q)))) > TOL.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] NSWEEP
|
||||
|
|
@ -175,7 +175,7 @@
|
|||
*> \param[in] LWORK
|
||||
*> \verbatim
|
||||
*> LWORK is INTEGER
|
||||
*> LWORK is the dimension of WORK. LWORK .GE. M.
|
||||
*> LWORK is the dimension of WORK. LWORK >= M.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[out] INFO
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@
|
|||
*> In terms of the columns of A, the first N1 columns are rotated 'against'
|
||||
*> the remaining N-N1 columns, trying to increase the angle between the
|
||||
*> corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is
|
||||
*> tiled using quadratic tiles of side KBL. Here, KBL is a tunning parmeter.
|
||||
*> tiled using quadratic tiles of side KBL. Here, KBL is a tunning parameter.
|
||||
*> The number of sweeps is given in NSWEEP and the orthogonality threshold
|
||||
*> is given in TOL.
|
||||
*> \endverbatim
|
||||
|
|
@ -147,7 +147,7 @@
|
|||
*> \param[in] MV
|
||||
*> \verbatim
|
||||
*> MV is INTEGER
|
||||
*> If JOBV .EQ. 'A', then MV rows of V are post-multipled by a
|
||||
*> If JOBV = 'A', then MV rows of V are post-multipled by a
|
||||
*> sequence of Jacobi rotations.
|
||||
*> If JOBV = 'N', then MV is not referenced.
|
||||
*> \endverbatim
|
||||
|
|
@ -155,9 +155,9 @@
|
|||
*> \param[in,out] V
|
||||
*> \verbatim
|
||||
*> V is COMPLEX*16 array, dimension (LDV,N)
|
||||
*> If JOBV .EQ. 'V' then N rows of V are post-multipled by a
|
||||
*> If JOBV = 'V' then N rows of V are post-multipled by a
|
||||
*> sequence of Jacobi rotations.
|
||||
*> If JOBV .EQ. 'A' then MV rows of V are post-multipled by a
|
||||
*> If JOBV = 'A' then MV rows of V are post-multipled by a
|
||||
*> sequence of Jacobi rotations.
|
||||
*> If JOBV = 'N', then V is not referenced.
|
||||
*> \endverbatim
|
||||
|
|
@ -166,8 +166,8 @@
|
|||
*> \verbatim
|
||||
*> LDV is INTEGER
|
||||
*> The leading dimension of the array V, LDV >= 1.
|
||||
*> If JOBV = 'V', LDV .GE. N.
|
||||
*> If JOBV = 'A', LDV .GE. MV.
|
||||
*> If JOBV = 'V', LDV >= N.
|
||||
*> If JOBV = 'A', LDV >= MV.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] EPS
|
||||
|
|
@ -187,7 +187,7 @@
|
|||
*> TOL is DOUBLE PRECISION
|
||||
*> TOL is the threshold for Jacobi rotations. For a pair
|
||||
*> A(:,p), A(:,q) of pivot columns, the Jacobi rotation is
|
||||
*> applied only if ABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL.
|
||||
*> applied only if ABS(COS(angle(A(:,p),A(:,q)))) > TOL.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] NSWEEP
|
||||
|
|
@ -205,7 +205,7 @@
|
|||
*> \param[in] LWORK
|
||||
*> \verbatim
|
||||
*> LWORK is INTEGER
|
||||
*> LWORK is the dimension of WORK. LWORK .GE. M.
|
||||
*> LWORK is the dimension of WORK. LWORK >= M.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[out] INFO
|
||||
|
|
|
|||
Loading…
Reference in New Issue