Update LAPACK to 3.9.0
This commit is contained in:
parent
1522f0f7f2
commit
688af253bf
|
@ -166,7 +166,7 @@
|
|||
*>
|
||||
*> \param[out] WORK
|
||||
*> \verbatim
|
||||
*> WORK is DOUBLE PRECISION array, dimension (4*N)
|
||||
*> WORK is DOUBLE PRECISION array, dimension (4*(N-1))
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[out] INFO
|
||||
|
|
|
@ -165,7 +165,7 @@
|
|||
*>
|
||||
*> \param[out] Z
|
||||
*> \verbatim
|
||||
*> Z is DOUBLE PRECISION array, dimension (2*N,K) )
|
||||
*> Z is DOUBLE PRECISION array, dimension (2*N,K)
|
||||
*> If JOBZ = 'V', then if INFO = 0 the first NS columns of Z
|
||||
*> contain the singular vectors of the matrix B corresponding to
|
||||
*> the selected singular values, with U in rows 1 to N and V
|
||||
|
|
|
@ -0,0 +1,92 @@
|
|||
*> \brief \b DCOMBSSQ adds two scaled sum of squares quantities.
|
||||
*
|
||||
* =========== DOCUMENTATION ===========
|
||||
*
|
||||
* Online html documentation available at
|
||||
* http://www.netlib.org/lapack/explore-html/
|
||||
*
|
||||
*
|
||||
* Definition:
|
||||
* ===========
|
||||
*
|
||||
* SUBROUTINE DCOMBSSQ( V1, V2 )
|
||||
*
|
||||
* .. Array Arguments ..
|
||||
* DOUBLE PRECISION V1( 2 ), V2( 2 )
|
||||
* ..
|
||||
*
|
||||
*
|
||||
*> \par Purpose:
|
||||
* =============
|
||||
*>
|
||||
*> \verbatim
|
||||
*>
|
||||
*> DCOMBSSQ adds two scaled sum of squares quantities, V1 := V1 + V2.
|
||||
*> That is,
|
||||
*>
|
||||
*> V1_scale**2 * V1_sumsq := V1_scale**2 * V1_sumsq
|
||||
*> + V2_scale**2 * V2_sumsq
|
||||
*> \endverbatim
|
||||
*
|
||||
* Arguments:
|
||||
* ==========
|
||||
*
|
||||
*> \param[in,out] V1
|
||||
*> \verbatim
|
||||
*> V1 is DOUBLE PRECISION array, dimension (2).
|
||||
*> The first scaled sum.
|
||||
*> V1(1) = V1_scale, V1(2) = V1_sumsq.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] V2
|
||||
*> \verbatim
|
||||
*> V2 is DOUBLE PRECISION array, dimension (2).
|
||||
*> The second scaled sum.
|
||||
*> V2(1) = V2_scale, V2(2) = V2_sumsq.
|
||||
*> \endverbatim
|
||||
*
|
||||
* Authors:
|
||||
* ========
|
||||
*
|
||||
*> \author Univ. of Tennessee
|
||||
*> \author Univ. of California Berkeley
|
||||
*> \author Univ. of Colorado Denver
|
||||
*> \author NAG Ltd.
|
||||
*
|
||||
*> \date November 2018
|
||||
*
|
||||
*> \ingroup OTHERauxiliary
|
||||
*
|
||||
* =====================================================================
|
||||
SUBROUTINE DCOMBSSQ( V1, V2 )
|
||||
*
|
||||
* -- LAPACK auxiliary routine (version 3.7.0) --
|
||||
* -- LAPACK is a software package provided by Univ. of Tennessee, --
|
||||
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
|
||||
* November 2018
|
||||
*
|
||||
* .. Array Arguments ..
|
||||
DOUBLE PRECISION V1( 2 ), V2( 2 )
|
||||
* ..
|
||||
*
|
||||
* =====================================================================
|
||||
*
|
||||
* .. Parameters ..
|
||||
DOUBLE PRECISION ZERO
|
||||
PARAMETER ( ZERO = 0.0D+0 )
|
||||
* ..
|
||||
* .. Executable Statements ..
|
||||
*
|
||||
IF( V1( 1 ).GE.V2( 1 ) ) THEN
|
||||
IF( V1( 1 ).NE.ZERO ) THEN
|
||||
V1( 2 ) = V1( 2 ) + ( V2( 1 ) / V1( 1 ) )**2 * V2( 2 )
|
||||
END IF
|
||||
ELSE
|
||||
V1( 2 ) = V2( 2 ) + ( V1( 1 ) / V2( 1 ) )**2 * V1( 2 )
|
||||
V1( 1 ) = V2( 1 )
|
||||
END IF
|
||||
RETURN
|
||||
*
|
||||
* End of DCOMBSSQ
|
||||
*
|
||||
END
|
|
@ -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.
|
||||
|
@ -359,9 +359,9 @@
|
|||
*> PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative
|
||||
*> refinement or not.
|
||||
*> Default: 1.0D+0
|
||||
*> = 0.0 : No refinement is performed, and no error bounds are
|
||||
*> = 0.0: No refinement is performed, and no error bounds are
|
||||
*> computed.
|
||||
*> = 1.0 : Use the double-precision refinement algorithm,
|
||||
*> = 1.0: Use the double-precision refinement algorithm,
|
||||
*> possibly with doubled-single computations if the
|
||||
*> compilation environment does not support DOUBLE
|
||||
*> PRECISION.
|
||||
|
|
|
@ -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.
|
||||
|
@ -482,9 +482,9 @@
|
|||
*> PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative
|
||||
*> refinement or not.
|
||||
*> Default: 1.0D+0
|
||||
*> = 0.0 : No refinement is performed, and no error bounds are
|
||||
*> = 0.0: No refinement is performed, and no error bounds are
|
||||
*> computed.
|
||||
*> = 1.0 : Use the extra-precise refinement algorithm.
|
||||
*> = 1.0: Use the extra-precise refinement algorithm.
|
||||
*> (other values are reserved for future use)
|
||||
*>
|
||||
*> PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual
|
||||
|
|
|
@ -47,10 +47,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 DGEBAL.
|
||||
*> \endverbatim
|
||||
|
|
|
@ -583,7 +583,9 @@
|
|||
IF( N.GT.I+1 )
|
||||
$ CALL DSWAP( N-I-1, A( I, I+2 ), LDA,
|
||||
$ A( I+1, I+2 ), LDA )
|
||||
CALL DSWAP( N, VS( 1, I ), 1, VS( 1, I+1 ), 1 )
|
||||
IF( WANTVS ) THEN
|
||||
CALL DSWAP( N, VS( 1, I ), 1, VS( 1, I+1 ), 1 )
|
||||
END IF
|
||||
A( I, I+1 ) = A( I+1, I )
|
||||
A( I+1, I ) = ZERO
|
||||
END IF
|
||||
|
|
|
@ -82,7 +82,7 @@
|
|||
*> 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=D*B. If A has heavily weighted
|
||||
*> rows, then using this condition number gives too pessimistic
|
||||
*> error bound.
|
||||
|
@ -133,7 +133,7 @@
|
|||
*> specified range. If A .NE. 0 is scaled so that the largest singular
|
||||
*> value of c*A is around DSQRT(BIG), BIG=SLAMCH('O'), then JOBR issues
|
||||
*> the licence to kill columns of A whose norm in c*A is less than
|
||||
*> DSQRT(SFMIN) (for JOBR.EQ.'R'), or less than SMALL=SFMIN/EPSLN,
|
||||
*> DSQRT(SFMIN) (for JOBR = 'R'), or less than SMALL=SFMIN/EPSLN,
|
||||
*> where SFMIN=SLAMCH('S'), EPSLN=SLAMCH('E').
|
||||
*> = 'N': Do not kill small columns of c*A. This option assumes that
|
||||
*> BLAS and QR factorizations and triangular solvers are
|
||||
|
@ -230,7 +230,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^t. In that case, [V] is computed
|
||||
*> in U as left singular vectors of A^t and then
|
||||
|
@ -252,7 +252,7 @@
|
|||
*> V is DOUBLE PRECISION 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^t. In that case, [U] is computed
|
||||
*> in V as right singular vectors of A^t and then
|
||||
|
@ -272,13 +272,13 @@
|
|||
*> \param[out] WORK
|
||||
*> \verbatim
|
||||
*> WORK is DOUBLE PRECISION array, dimension (LWORK)
|
||||
*> On exit, if N.GT.0 .AND. M.GT.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
|
||||
*> that SCALE*SVA(1:N) are the computed singular values
|
||||
*> of A. (See the description of SVA().)
|
||||
*> WORK(2) = See the description of WORK(1).
|
||||
*> WORK(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 DSQRT(||(R^t * R)^(-1)||_1).
|
||||
*> It is computed using DPOCON. It holds
|
||||
*> N^(-1/4) * SCONDA <= ||R^(-1)||_2 <= N^(1/4) * SCONDA
|
||||
|
@ -297,7 +297,7 @@
|
|||
*> triangular factor in the first QR factorization.
|
||||
*> WORK(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.
|
||||
*>
|
||||
|
@ -313,8 +313,8 @@
|
|||
*> Length of WORK to confirm proper allocation of work space.
|
||||
*> LWORK depends on the job:
|
||||
*>
|
||||
*> If only SIGMA is needed ( JOBU.EQ.'N', JOBV.EQ.'N' ) and
|
||||
*> -> .. no scaled condition estimate required (JOBE.EQ.'N'):
|
||||
*> If only SIGMA is needed (JOBU = 'N', JOBV = 'N') and
|
||||
*> -> .. no scaled condition estimate required (JOBE = 'N'):
|
||||
*> LWORK >= max(2*M+N,4*N+1,7). This is the minimal requirement.
|
||||
*> ->> 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
|
||||
|
@ -330,7 +330,7 @@
|
|||
*> LWORK >= max(2*M+N,N+LWORK(DGEQP3),N+LWORK(DGEQRF),
|
||||
*> N+N*N+LWORK(DPOCON),7).
|
||||
*>
|
||||
*> If SIGMA and the right singular vectors are needed (JOBV.EQ.'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).
|
||||
*> -> For optimal performance, LWORK >= max(2*M+N,3*N+(N+1)*NB,7),
|
||||
*> where NB is the optimal block size for DGEQP3, DGEQRF, DGELQF,
|
||||
|
@ -341,19 +341,19 @@
|
|||
*> If SIGMA and the left singular vectors are needed
|
||||
*> -> the minimal requirement is LWORK >= max(2*M+N,4*N+1,7).
|
||||
*> -> For optimal performance:
|
||||
*> if JOBU.EQ.'U' :: LWORK >= max(2*M+N,3*N+(N+1)*NB,7),
|
||||
*> if JOBU.EQ.'F' :: LWORK >= max(2*M+N,3*N+(N+1)*NB,N+M*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),
|
||||
*> where NB is the optimal block size for DGEQP3, DGEQRF, DORMQR.
|
||||
*> In general, the optimal length LWORK is computed as
|
||||
*> LWORK >= max(2*M+N,N+LWORK(DGEQP3),N+LWORK(DPOCON),
|
||||
*> 2*N+LWORK(DGEQRF), N+LWORK(DORMQR)).
|
||||
*> Here LWORK(DORMQR) equals N*NB (for JOBU.EQ.'U') or
|
||||
*> M*NB (for JOBU.EQ.'F').
|
||||
*> Here LWORK(DORMQR) equals N*NB (for JOBU = 'U') or
|
||||
*> M*NB (for JOBU = 'F').
|
||||
*>
|
||||
*> If the full SVD is needed: (JOBU.EQ.'U' or JOBU.EQ.'F') and
|
||||
*> -> if JOBV.EQ.'V'
|
||||
*> If the full SVD is needed: (JOBU = 'U' or JOBU = 'F') and
|
||||
*> -> if JOBV = 'V'
|
||||
*> the minimal requirement is LWORK >= max(2*M+N,6*N+2*N*N).
|
||||
*> -> if JOBV.EQ.'J' the minimal requirement is
|
||||
*> -> if JOBV = 'J' the minimal requirement is
|
||||
*> LWORK >= max(2*M+N, 4*N+N*N,2*N+N*N+6).
|
||||
*> -> For optimal performance, LWORK should be additionally
|
||||
*> larger than N+M*NB, where NB is the optimal block size
|
||||
|
@ -369,7 +369,7 @@
|
|||
*> 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.
|
||||
*> \endverbatim
|
||||
|
@ -377,10 +377,10 @@
|
|||
*> \param[out] INFO
|
||||
*> \verbatim
|
||||
*> INFO is INTEGER
|
||||
*> < 0 : if INFO = -i, then the i-th argument had an illegal value.
|
||||
*> = 0 : successful exit;
|
||||
*> > 0 : DGEJSV did not converge in the maximal allowed number
|
||||
*> of sweeps. The computed values may be inaccurate.
|
||||
*> < 0: if INFO = -i, then the i-th argument had an illegal value.
|
||||
*> = 0: successful exit;
|
||||
*> > 0: DGEJSV did not converge in the maximal allowed number
|
||||
*> of sweeps. The computed values may be inaccurate.
|
||||
*> \endverbatim
|
||||
*
|
||||
* Authors:
|
||||
|
@ -953,7 +953,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 = DSQRT(DBLE(N))*EPSLN
|
||||
DO 3001 p = 2, N
|
||||
|
@ -965,7 +965,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 = DSQRT(SFMIN)
|
||||
|
@ -1294,7 +1294,7 @@
|
|||
CALL DPOCON('Lower',NR,WORK(2*N+1),NR,ONE,TEMP1,
|
||||
$ WORK(2*N+NR*NR+1),IWORK(M+2*N+1),IERR)
|
||||
CONDR1 = ONE / DSQRT(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. DSQRT(DBLE(N))
|
||||
|
@ -1335,7 +1335,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 DGEQP3
|
||||
* should be replaced with eg. CALL SGEQPX (ACM TOMS #782)
|
||||
|
@ -1388,7 +1388,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 DLACPY( 'U', NR, NR, V, LDV, WORK(2*N+1), N )
|
||||
|
@ -1638,7 +1638,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 DGELQ
|
||||
*
|
||||
* Definition:
|
||||
* ===========
|
||||
|
@ -17,7 +18,17 @@
|
|||
* =============
|
||||
*>
|
||||
*> \verbatim
|
||||
*> DGELQ computes a LQ factorization of an M-by-N matrix A.
|
||||
*>
|
||||
*> DGELQ computes an LQ factorization of a real 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 DGELQ( 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
|
||||
*>
|
||||
*> DGELQ2 computes an LQ factorization of a real m by n matrix A:
|
||||
*> A = L * Q.
|
||||
*> DGELQ2 computes an LQ factorization of a real 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 doubleGEcomputational
|
||||
*
|
||||
|
@ -121,10 +129,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE DGELQ2( 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
|
||||
*>
|
||||
*> DGELQF computes an LQ factorization of a real 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 doubleGEcomputational
|
||||
*
|
||||
|
@ -135,10 +143,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE DGELQF( 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 DGEMLQ
|
||||
*
|
||||
* 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 DGEMQR
|
||||
*
|
||||
* 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 DGEQR
|
||||
*
|
||||
* Definition:
|
||||
* ===========
|
||||
|
@ -17,7 +18,18 @@
|
|||
* =============
|
||||
*>
|
||||
*> \verbatim
|
||||
*> DGEQR computes a QR factorization of an M-by-N matrix A.
|
||||
*>
|
||||
*> DGEQR computes a QR factorization of a real 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 DGEQR( 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
|
||||
*>
|
||||
*> DGEQR2 computes a QR factorization of a real m by n matrix A:
|
||||
*> A = Q * R.
|
||||
*> DGEQR2 computes a QR factorization of a real 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 doubleGEcomputational
|
||||
*
|
||||
|
@ -121,10 +130,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE DGEQR2( 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
|
||||
*>
|
||||
*> DGEQR2P computes a QR factorization of a real m by n matrix A:
|
||||
*> A = Q * R. The diagonal entries of R are nonnegative.
|
||||
*> DGEQR2P computes a QR factorization of a real 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 doubleGEcomputational
|
||||
*
|
||||
|
@ -124,10 +134,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE DGEQR2P( 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
|
||||
*>
|
||||
*> DGEQRF computes a QR factorization of a real 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 doubleGEcomputational
|
||||
*
|
||||
|
@ -136,10 +145,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE DGEQRF( 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
|
||||
*>
|
||||
*> DGEQRFP computes a QR factorization of a real M-by-N matrix A:
|
||||
*> A = Q * R. The diagonal entries of R are nonnegative.
|
||||
*> DGEQR2P computes a QR factorization of a real 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 doubleGEcomputational
|
||||
*
|
||||
|
@ -139,10 +149,10 @@
|
|||
* =====================================================================
|
||||
SUBROUTINE DGEQRFP( 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
|
||||
|
|
|
@ -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.
|
||||
|
@ -334,9 +334,9 @@
|
|||
*> PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative
|
||||
*> refinement or not.
|
||||
*> Default: 1.0D+0
|
||||
*> = 0.0 : No refinement is performed, and no error bounds are
|
||||
*> = 0.0: No refinement is performed, and no error bounds are
|
||||
*> computed.
|
||||
*> = 1.0 : Use the double-precision refinement algorithm,
|
||||
*> = 1.0: Use the double-precision refinement algorithm,
|
||||
*> possibly with doubled-single computations if the
|
||||
*> compilation environment does not support DOUBLE
|
||||
*> PRECISION.
|
||||
|
|
|
@ -90,7 +90,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:
|
||||
|
@ -151,7 +151,7 @@
|
|||
* ..
|
||||
* .. Executable Statements ..
|
||||
*
|
||||
* Set constant to control owerflow
|
||||
* Set constant to control overflow
|
||||
*
|
||||
EPS = DLAMCH( 'P' )
|
||||
SMLNUM = DLAMCH( 'S' ) / EPS
|
||||
|
|
|
@ -322,7 +322,7 @@
|
|||
*
|
||||
IF( WNTQN ) THEN
|
||||
* dbdsdc needs only 4*N (or 6*N for uplo=L for LAPACK <= 3.6)
|
||||
* keep 7*N for backwards compatability.
|
||||
* keep 7*N for backwards compatibility.
|
||||
BDSPAC = 7*N
|
||||
ELSE
|
||||
BDSPAC = 3*N*N + 4*N
|
||||
|
@ -448,7 +448,7 @@
|
|||
*
|
||||
IF( WNTQN ) THEN
|
||||
* dbdsdc needs only 4*N (or 6*N for uplo=L for LAPACK <= 3.6)
|
||||
* keep 7*N for backwards compatability.
|
||||
* keep 7*N for backwards compatibility.
|
||||
BDSPAC = 7*M
|
||||
ELSE
|
||||
BDSPAC = 3*M*M + 4*M
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -90,13 +90,13 @@
|
|||
*> JOBV is CHARACTER*1
|
||||
*> Specifies whether to compute the right singular vectors, that
|
||||
*> is, the matrix V:
|
||||
*> = 'V' : the matrix V is computed and returned in the array V
|
||||
*> = 'A' : the Jacobi rotations are applied to the MV-by-N
|
||||
*> = 'V': the matrix V is computed and returned in the array V
|
||||
*> = 'A': the Jacobi rotations are applied to the MV-by-N
|
||||
*> array V. In other words, the right singular vector
|
||||
*> matrix V is not computed explicitly, instead it is
|
||||
*> applied to an MV-by-N matrix initially stored in the
|
||||
*> first MV rows of V.
|
||||
*> = 'N' : the matrix V is not computed and the array V is not
|
||||
*> = 'N': the matrix V is not computed and the array V is not
|
||||
*> referenced
|
||||
*> \endverbatim
|
||||
*>
|
||||
|
@ -118,8 +118,8 @@
|
|||
*> A is DOUBLE PRECISION 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
|
||||
|
@ -129,9 +129,9 @@
|
|||
*> in the array WORK as RANKA=NINT(WORK(2)). Also see the
|
||||
*> descriptions of SVA and WORK. The computed columns of U
|
||||
*> are mutually numerically orthogonal up to approximately
|
||||
*> TOL=DSQRT(M)*EPS (default); or TOL=CTOL*EPS (JOBU.EQ.'C'),
|
||||
*> TOL=DSQRT(M)*EPS (default); or TOL=CTOL*EPS (JOBU = 'C'),
|
||||
*> see the description of JOBU.
|
||||
*> If INFO .GT. 0 :
|
||||
*> If INFO > 0 :
|
||||
*> the procedure DGESVJ 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
|
||||
|
@ -140,8 +140,8 @@
|
|||
*> input matrix A in the sense that the residual
|
||||
*> ||A-SCALE*U*SIGMA*V^T||_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
|
||||
|
@ -150,7 +150,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 DGESVJ did not converge in the given number
|
||||
*> of iterations (sweeps).
|
||||
*> \endverbatim
|
||||
|
@ -165,9 +165,9 @@
|
|||
*> \verbatim
|
||||
*> SVA is DOUBLE PRECISION array, dimension (N)
|
||||
*> On exit :
|
||||
*> If INFO .EQ. 0 :
|
||||
*> If INFO = 0 :
|
||||
*> depending on the value SCALE = WORK(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.
|
||||
|
@ -175,7 +175,7 @@
|
|||
*> The singular values of A are SCALE*SVA(1:N), and this
|
||||
*> 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 DGESVJ did not converge in the given number of
|
||||
*> iterations (sweeps) and SCALE*SVA(1:N) may not be accurate.
|
||||
*> \endverbatim
|
||||
|
@ -183,7 +183,7 @@
|
|||
*> \param[in] MV
|
||||
*> \verbatim
|
||||
*> MV is INTEGER
|
||||
*> If JOBV .EQ. 'A', then the product of Jacobi rotations in DGESVJ
|
||||
*> If JOBV = 'A', then the product of Jacobi rotations in DGESVJ
|
||||
*> is applied to the first MV rows of V. See the description of JOBV.
|
||||
*> \endverbatim
|
||||
*>
|
||||
|
@ -201,16 +201,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] WORK
|
||||
*> \verbatim
|
||||
*> WORK is DOUBLE PRECISION array, dimension (LWORK)
|
||||
*> On entry :
|
||||
*> If JOBU .EQ. 'C' :
|
||||
*> If JOBU = 'C' :
|
||||
*> WORK(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').
|
||||
|
@ -230,7 +230,7 @@
|
|||
*> WORK(5) = max_{i.NE.j} |COS(A(:,i),A(:,j))| in the last sweep.
|
||||
*> This is useful information in cases when DGESVJ 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.
|
||||
*> WORK(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.
|
||||
|
@ -245,9 +245,9 @@
|
|||
*> \param[out] INFO
|
||||
*> \verbatim
|
||||
*> INFO is INTEGER
|
||||
*> = 0 : successful exit.
|
||||
*> < 0 : if INFO = -i, then the i-th argument had an illegal value
|
||||
*> > 0 : DGESVJ did not converge in the maximal allowed number (30)
|
||||
*> = 0: successful exit.
|
||||
*> < 0: if INFO = -i, then the i-th argument had an illegal value
|
||||
*> > 0: DGESVJ did not converge in the maximal allowed number (30)
|
||||
*> of sweeps. The output may still be useful. See the
|
||||
*> description of WORK.
|
||||
*> \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.
|
||||
|
@ -462,9 +462,9 @@
|
|||
*> PARAMS(LA_LINRX_ITREF_I = 1) : Whether to perform iterative
|
||||
*> refinement or not.
|
||||
*> Default: 1.0D+0
|
||||
*> = 0.0 : No refinement is performed, and no error bounds are
|
||||
*> = 0.0: No refinement is performed, and no error bounds are
|
||||
*> computed.
|
||||
*> = 1.0 : Use the extra-precise refinement algorithm.
|
||||
*> = 1.0: Use the extra-precise refinement algorithm.
|
||||
*> (other values are reserved for future use)
|
||||
*>
|
||||
*> PARAMS(LA_LINRX_ITHRESH_I = 2) : Maximum number of residual
|
||||
|
|
|
@ -85,7 +85,7 @@
|
|||
*> \verbatim
|
||||
*> INFO is INTEGER
|
||||
*> = 0: successful exit
|
||||
*> > 0: if INFO = k, U(k, k) is likely to produce owerflow if
|
||||
*> > 0: if INFO = k, U(k, k) is likely to produce overflow if
|
||||
*> we try to solve for x in Ax = b. So U is perturbed to
|
||||
*> avoid the overflow.
|
||||
*> \endverbatim
|
||||
|
|
|
@ -1,3 +1,5 @@
|
|||
*> \brief \b DGETSLS
|
||||
*
|
||||
* Definition:
|
||||
* ===========
|
||||
*
|
||||
|
|
|
@ -131,10 +131,10 @@
|
|||
*> \verbatim
|
||||
*> SENSE is CHARACTER*1
|
||||
*> Determines which reciprocal condition numbers are computed.
|
||||
*> = 'N' : None are computed;
|
||||
*> = 'E' : Computed for average of selected eigenvalues only;
|
||||
*> = 'V' : Computed for selected deflating subspaces only;
|
||||
*> = 'B' : Computed for both.
|
||||
*> = 'N': None are computed;
|
||||
*> = 'E': Computed for average of selected eigenvalues only;
|
||||
*> = 'V': Computed for selected deflating subspaces only;
|
||||
*> = 'B': Computed for both.
|
||||
*> If SENSE = 'E', 'V', or 'B', SORT must equal 'S'.
|
||||
*> \endverbatim
|
||||
*>
|
||||
|
|
|
@ -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 DOUBLE PRECISION 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 DABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL.
|
||||
*> applied only if DABS(COS(angle(A(:,p),A(:,q)))) > TOL.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] NSWEEP
|
||||
|
@ -175,14 +175,14 @@
|
|||
*> \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
|
||||
*> \verbatim
|
||||
*> INFO is INTEGER
|
||||
*> = 0 : successful exit.
|
||||
*> < 0 : if INFO = -i, then the i-th argument had an illegal value
|
||||
*> = 0: successful exit.
|
||||
*> < 0: if INFO = -i, then the i-th argument had an illegal value
|
||||
*> \endverbatim
|
||||
*
|
||||
* Authors:
|
||||
|
@ -1045,7 +1045,7 @@
|
|||
|
||||
1993 CONTINUE
|
||||
* end i=1:NSWEEP loop
|
||||
* #:) Reaching this point means that the procedure has comleted the given
|
||||
* #:) Reaching this point means that the procedure has completed the given
|
||||
* number of iterations.
|
||||
INFO = NSWEEP - 1
|
||||
GO TO 1995
|
||||
|
|
|
@ -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,27 +147,27 @@
|
|||
*> \param[in] MV
|
||||
*> \verbatim
|
||||
*> MV is INTEGER
|
||||
*> If JOBV .EQ. 'A', then MV rows of V are post-multipled by a
|
||||
*> sequence of Jacobi rotations.
|
||||
*> If JOBV = 'N', then MV is not referenced.
|
||||
*> 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
|
||||
*>
|
||||
*> \param[in,out] V
|
||||
*> \verbatim
|
||||
*> V is DOUBLE PRECISION array, dimension (LDV,N)
|
||||
*> If JOBV .EQ. '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
|
||||
*> sequence of Jacobi rotations.
|
||||
*> If JOBV = 'N', then V is not referenced.
|
||||
*> If JOBV = 'V', then N rows of V are post-multipled by a
|
||||
*> sequence of Jacobi rotations.
|
||||
*> 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
|
||||
*>
|
||||
*> \param[in] LDV
|
||||
*> \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 DABS(COS(angle(A(:,p),A(:,q)))) .GT. TOL.
|
||||
*> applied only if DABS(COS(angle(A(:,p),A(:,q)))) > TOL.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] NSWEEP
|
||||
|
@ -205,14 +205,14 @@
|
|||
*> \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
|
||||
*> \verbatim
|
||||
*> INFO is INTEGER
|
||||
*> = 0 : successful exit.
|
||||
*> < 0 : if INFO = -i, then the i-th argument had an illegal value
|
||||
*> = 0: successful exit.
|
||||
*> < 0: if INFO = -i, then the i-th argument had an illegal value
|
||||
*> \endverbatim
|
||||
*
|
||||
* Authors:
|
||||
|
|
|
@ -70,7 +70,7 @@
|
|||
*> \param[in] N
|
||||
*> \verbatim
|
||||
*> N is INTEGER
|
||||
*> The order of the matrix H. N .GE. 0.
|
||||
*> The order of the matrix H. N >= 0.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] ILO
|
||||
|
@ -87,7 +87,7 @@
|
|||
*> set by a previous call to DGEBAL, and then passed to ZGEHRD
|
||||
*> when the matrix output by DGEBAL is reduced to Hessenberg
|
||||
*> form. Otherwise ILO and IHI should be set to 1 and N
|
||||
*> respectively. If N.GT.0, then 1.LE.ILO.LE.IHI.LE.N.
|
||||
*> respectively. If N > 0, then 1 <= ILO <= IHI <= N.
|
||||
*> If N = 0, then ILO = 1 and IHI = 0.
|
||||
*> \endverbatim
|
||||
*>
|
||||
|
@ -100,20 +100,20 @@
|
|||
*> (the Schur form); 2-by-2 diagonal blocks (corresponding to
|
||||
*> complex conjugate pairs of eigenvalues) are returned in
|
||||
*> standard form, with H(i,i) = H(i+1,i+1) and
|
||||
*> H(i+1,i)*H(i,i+1).LT.0. If INFO = 0 and JOB = 'E', the
|
||||
*> H(i+1,i)*H(i,i+1) < 0. If INFO = 0 and JOB = 'E', the
|
||||
*> contents of H are unspecified on exit. (The output value of
|
||||
*> H when INFO.GT.0 is given under the description of INFO
|
||||
*> H when INFO > 0 is given under the description of INFO
|
||||
*> below.)
|
||||
*>
|
||||
*> Unlike earlier versions of DHSEQR, this subroutine may
|
||||
*> explicitly H(i,j) = 0 for i.GT.j and j = 1, 2, ... ILO-1
|
||||
*> explicitly H(i,j) = 0 for i > j and j = 1, 2, ... ILO-1
|
||||
*> or j = IHI+1, IHI+2, ... N.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] LDH
|
||||
*> \verbatim
|
||||
*> LDH is INTEGER
|
||||
*> The leading dimension of the array H. LDH .GE. max(1,N).
|
||||
*> The leading dimension of the array H. LDH >= max(1,N).
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[out] WR
|
||||
|
@ -128,8 +128,8 @@
|
|||
*> The real and imaginary parts, respectively, of the computed
|
||||
*> eigenvalues. If two eigenvalues are computed as a complex
|
||||
*> conjugate pair, they are stored in consecutive elements of
|
||||
*> WR and WI, say the i-th and (i+1)th, with WI(i) .GT. 0 and
|
||||
*> WI(i+1) .LT. 0. If JOB = 'S', the eigenvalues are stored in
|
||||
*> WR and WI, say the i-th and (i+1)th, with WI(i) > 0 and
|
||||
*> WI(i+1) < 0. If JOB = 'S', the eigenvalues are stored in
|
||||
*> the same order as on the diagonal of the Schur form returned
|
||||
*> in H, with WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2
|
||||
*> diagonal block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and
|
||||
|
@ -148,7 +148,7 @@
|
|||
*> if INFO = 0, Z contains Q*Z.
|
||||
*> Normally Q is the orthogonal matrix generated by DORGHR
|
||||
*> after the call to DGEHRD which formed the Hessenberg matrix
|
||||
*> H. (The output value of Z when INFO.GT.0 is given under
|
||||
*> H. (The output value of Z when INFO > 0 is given under
|
||||
*> the description of INFO below.)
|
||||
*> \endverbatim
|
||||
*>
|
||||
|
@ -156,7 +156,7 @@
|
|||
*> \verbatim
|
||||
*> LDZ is INTEGER
|
||||
*> The leading dimension of the array Z. if COMPZ = 'I' or
|
||||
*> COMPZ = 'V', then LDZ.GE.MAX(1,N). Otherwize, LDZ.GE.1.
|
||||
*> COMPZ = 'V', then LDZ >= MAX(1,N). Otherwise, LDZ >= 1.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[out] WORK
|
||||
|
@ -169,7 +169,7 @@
|
|||
*> \param[in] LWORK
|
||||
*> \verbatim
|
||||
*> LWORK is INTEGER
|
||||
*> The dimension of the array WORK. LWORK .GE. max(1,N)
|
||||
*> The dimension of the array WORK. LWORK >= max(1,N)
|
||||
*> is sufficient and delivers very good and sometimes
|
||||
*> optimal performance. However, LWORK as large as 11*N
|
||||
*> may be required for optimal performance. A workspace
|
||||
|
@ -187,21 +187,21 @@
|
|||
*> \param[out] INFO
|
||||
*> \verbatim
|
||||
*> INFO is INTEGER
|
||||
*> = 0: successful exit
|
||||
*> .LT. 0: if INFO = -i, the i-th argument had an illegal
|
||||
*> = 0: successful exit
|
||||
*> < 0: if INFO = -i, the i-th argument had an illegal
|
||||
*> value
|
||||
*> .GT. 0: if INFO = i, DHSEQR failed to compute all of
|
||||
*> > 0: if INFO = i, DHSEQR failed to compute all of
|
||||
*> the eigenvalues. Elements 1:ilo-1 and i+1:n of WR
|
||||
*> and WI contain those eigenvalues which have been
|
||||
*> successfully computed. (Failures are rare.)
|
||||
*>
|
||||
*> If INFO .GT. 0 and JOB = 'E', then on exit, the
|
||||
*> If INFO > 0 and JOB = 'E', then on exit, the
|
||||
*> remaining unconverged eigenvalues are the eigen-
|
||||
*> values of the upper Hessenberg matrix rows and
|
||||
*> columns ILO through INFO of the final, output
|
||||
*> value of H.
|
||||
*>
|
||||
*> If INFO .GT. 0 and JOB = 'S', then on exit
|
||||
*> If INFO > 0 and JOB = 'S', then on exit
|
||||
*>
|
||||
*> (*) (initial value of H)*U = U*(final value of H)
|
||||
*>
|
||||
|
@ -209,19 +209,19 @@
|
|||
*> value of H is upper Hessenberg and quasi-triangular
|
||||
*> in rows and columns INFO+1 through IHI.
|
||||
*>
|
||||
*> If INFO .GT. 0 and COMPZ = 'V', then on exit
|
||||
*> If INFO > 0 and COMPZ = 'V', then on exit
|
||||
*>
|
||||
*> (final value of Z) = (initial value of Z)*U
|
||||
*>
|
||||
*> where U is the orthogonal matrix in (*) (regard-
|
||||
*> less of the value of JOB.)
|
||||
*>
|
||||
*> If INFO .GT. 0 and COMPZ = 'I', then on exit
|
||||
*> If INFO > 0 and COMPZ = 'I', then on exit
|
||||
*> (final value of Z) = U
|
||||
*> where U is the orthogonal matrix in (*) (regard-
|
||||
*> less of the value of JOB.)
|
||||
*>
|
||||
*> If INFO .GT. 0 and COMPZ = 'N', then Z is not
|
||||
*> If INFO > 0 and COMPZ = 'N', then Z is not
|
||||
*> accessed.
|
||||
*> \endverbatim
|
||||
*
|
||||
|
@ -261,8 +261,8 @@
|
|||
*> This depends on ILO, IHI and NS. NS is the
|
||||
*> number of simultaneous shifts returned
|
||||
*> by ILAENV(ISPEC=15). (See ISPEC=15 below.)
|
||||
*> The default for (IHI-ILO+1).LE.500 is NS.
|
||||
*> The default for (IHI-ILO+1).GT.500 is 3*NS/2.
|
||||
*> The default for (IHI-ILO+1) <= 500 is NS.
|
||||
*> The default for (IHI-ILO+1) > 500 is 3*NS/2.
|
||||
*>
|
||||
*> ISPEC=14: Nibble crossover point. (See IPARMQ for
|
||||
*> details.) Default: 14% of deflation window
|
||||
|
@ -341,8 +341,8 @@
|
|||
PARAMETER ( NTINY = 11 )
|
||||
*
|
||||
* ==== NL allocates some local workspace to help small matrices
|
||||
* . through a rare DLAHQR failure. NL .GT. NTINY = 11 is
|
||||
* . required and NL .LE. NMIN = ILAENV(ISPEC=12,...) is recom-
|
||||
* . through a rare DLAHQR failure. NL > NTINY = 11 is
|
||||
* . required and NL <= NMIN = ILAENV(ISPEC=12,...) is recom-
|
||||
* . mended. (The default value of NMIN is 75.) Using NL = 49
|
||||
* . allows up to six simultaneous shifts and a 16-by-16
|
||||
* . deflation window. ====
|
||||
|
|
|
@ -141,13 +141,13 @@
|
|||
*> i > 0: The ith argument is invalid.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] WORK
|
||||
*> \param[out] WORK
|
||||
*> \verbatim
|
||||
*> WORK is DOUBLE PRECISION array, dimension (5*N).
|
||||
*> Workspace.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] IWORK
|
||||
*> \param[out] IWORK
|
||||
*> \verbatim
|
||||
*> IWORK is INTEGER array, dimension (N).
|
||||
*> Workspace.
|
||||
|
|
|
@ -66,19 +66,19 @@
|
|||
*> \verbatim
|
||||
*> PREC_TYPE is INTEGER
|
||||
*> Specifies the intermediate precision to be used in refinement.
|
||||
*> The value is defined by ILAPREC(P) where P is a CHARACTER and
|
||||
*> P = 'S': Single
|
||||
*> The value is defined by ILAPREC(P) where P is a CHARACTER and P
|
||||
*> = 'S': Single
|
||||
*> = 'D': Double
|
||||
*> = 'I': Indigenous
|
||||
*> = 'X', 'E': Extra
|
||||
*> = 'X' or 'E': Extra
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] TRANS_TYPE
|
||||
*> \verbatim
|
||||
*> TRANS_TYPE is INTEGER
|
||||
*> Specifies the transposition operation on A.
|
||||
*> The value is defined by ILATRANS(T) where T is a CHARACTER and
|
||||
*> T = 'N': No transpose
|
||||
*> The value is defined by ILATRANS(T) where T is a CHARACTER and T
|
||||
*> = 'N': No transpose
|
||||
*> = 'T': Transpose
|
||||
*> = 'C': Conjugate transpose
|
||||
*> \endverbatim
|
||||
|
@ -270,7 +270,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
|
||||
|
|
|
@ -123,13 +123,13 @@
|
|||
*> i > 0: The ith argument is invalid.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] WORK
|
||||
*> \param[out] WORK
|
||||
*> \verbatim
|
||||
*> WORK is DOUBLE PRECISION array, dimension (3*N).
|
||||
*> Workspace.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] IWORK
|
||||
*> \param[out] IWORK
|
||||
*> \verbatim
|
||||
*> IWORK is INTEGER array, dimension (N).
|
||||
*> Workspace.
|
||||
|
|
|
@ -64,19 +64,19 @@
|
|||
*> \verbatim
|
||||
*> PREC_TYPE is INTEGER
|
||||
*> Specifies the intermediate precision to be used in refinement.
|
||||
*> The value is defined by ILAPREC(P) where P is a CHARACTER and
|
||||
*> P = 'S': Single
|
||||
*> The value is defined by ILAPREC(P) where P is a CHARACTER and P
|
||||
*> = 'S': Single
|
||||
*> = 'D': Double
|
||||
*> = 'I': Indigenous
|
||||
*> = 'X', 'E': Extra
|
||||
*> = 'X' or 'E': Extra
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] TRANS_TYPE
|
||||
*> \verbatim
|
||||
*> TRANS_TYPE is INTEGER
|
||||
*> Specifies the transposition operation on A.
|
||||
*> The value is defined by ILATRANS(T) where T is a CHARACTER and
|
||||
*> T = 'N': No transpose
|
||||
*> The value is defined by ILATRANS(T) where T is a CHARACTER and T
|
||||
*> = 'N': No transpose
|
||||
*> = 'T': Transpose
|
||||
*> = 'C': Conjugate transpose
|
||||
*> \endverbatim
|
||||
|
@ -256,7 +256,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
|
||||
*> ERRS_C is not accessed. If N_ERR_BNDS .LT. 3, then at most
|
||||
*> ERRS_C is not accessed. If N_ERR_BNDS < 3, then at most
|
||||
*> the first (:,N_ERR_BNDS) entries are returned.
|
||||
*>
|
||||
*> The first index in ERRS_C(i,:) corresponds to the ith
|
||||
|
|
|
@ -113,13 +113,13 @@
|
|||
*> i > 0: The ith argument is invalid.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] WORK
|
||||
*> \param[out] WORK
|
||||
*> \verbatim
|
||||
*> WORK is DOUBLE PRECISION array, dimension (3*N).
|
||||
*> Workspace.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] IWORK
|
||||
*> \param[out] IWORK
|
||||
*> \verbatim
|
||||
*> IWORK is INTEGER array, dimension (N).
|
||||
*> Workspace.
|
||||
|
|
|
@ -65,11 +65,11 @@
|
|||
*> \verbatim
|
||||
*> PREC_TYPE is INTEGER
|
||||
*> Specifies the intermediate precision to be used in refinement.
|
||||
*> The value is defined by ILAPREC(P) where P is a CHARACTER and
|
||||
*> P = 'S': Single
|
||||
*> The value is defined by ILAPREC(P) where P is a CHARACTER and P
|
||||
*> = 'S': Single
|
||||
*> = 'D': Double
|
||||
*> = 'I': Indigenous
|
||||
*> = 'X', 'E': Extra
|
||||
*> = 'X' or 'E': Extra
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] UPLO
|
||||
|
@ -246,7 +246,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
|
||||
|
|
|
@ -85,7 +85,7 @@
|
|||
*> The leading dimension of the array AF. LDAF >= max(1,N).
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] WORK
|
||||
*> \param[out] WORK
|
||||
*> \verbatim
|
||||
*> WORK is DOUBLE PRECISION array, dimension (2*N)
|
||||
*> \endverbatim
|
||||
|
|
|
@ -119,13 +119,13 @@
|
|||
*> i > 0: The ith argument is invalid.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] WORK
|
||||
*> \param[out] WORK
|
||||
*> \verbatim
|
||||
*> WORK is DOUBLE PRECISION array, dimension (3*N).
|
||||
*> Workspace.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] IWORK
|
||||
*> \param[out] IWORK
|
||||
*> \verbatim
|
||||
*> IWORK is INTEGER array, dimension (N).
|
||||
*> Workspace.
|
||||
|
|
|
@ -67,11 +67,11 @@
|
|||
*> \verbatim
|
||||
*> PREC_TYPE is INTEGER
|
||||
*> Specifies the intermediate precision to be used in refinement.
|
||||
*> The value is defined by ILAPREC(P) where P is a CHARACTER and
|
||||
*> P = 'S': Single
|
||||
*> The value is defined by ILAPREC(P) where P is a CHARACTER and P
|
||||
*> = 'S': Single
|
||||
*> = 'D': Double
|
||||
*> = 'I': Indigenous
|
||||
*> = 'X', 'E': Extra
|
||||
*> = 'X' or 'E': Extra
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] UPLO
|
||||
|
@ -255,7 +255,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
|
||||
|
|
|
@ -101,7 +101,7 @@
|
|||
*> as determined by DSYTRF.
|
||||
*> \endverbatim
|
||||
*>
|
||||
*> \param[in] WORK
|
||||
*> \param[out] WORK
|
||||
*> \verbatim
|
||||
*> WORK is DOUBLE PRECISION array, dimension (2*N)
|
||||
*> \endverbatim
|
||||
|
|
|
@ -36,7 +36,7 @@
|
|||
*> DLA_WWADDW adds a vector W into a doubled-single vector (X, Y).
|
||||
*>
|
||||
*> This works for all extant IBM's hex and binary floating point
|
||||
*> arithmetics, but not for decimal.
|
||||
*> arithmetic, but not for decimal.
|
||||
*> \endverbatim
|
||||
*
|
||||
* Arguments:
|
||||
|
|
Loading…
Reference in New Issue