*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> ( 1 + ( n - 1 )*abs( INCX ) ).
*> Before entry, the incremented array X must contain the n
*> element vector x. On exit, X is overwritten with the
-*> tranformed vector x.
+*> transformed vector x.
*> \endverbatim
*>
*> \param[in] INCX
*> \verbatim
*> INFO is INTEGER
*> < 0 : if INFO = -i, then the i-th argument had an illegal value.
-*> = 0 : successfull exit;
+*> = 0 : successful exit;
*> > 0 : CGEJSV did not converge in the maximal allowed number
*> of sweeps. The computed values may be inaccurate.
*> \endverbatim
*> implemented as in [3]. We have a new version of CGEQP3 under development
*> that is more robust than the current one in LAPACK, with a cleaner cut in
*> rank defficient cases. It will be available in the SIGMA library [4].
-*> If M is much larger than N, it is obvious that the inital QRF with
+*> If M is much larger than N, it is obvious that the initial QRF with
*> column pivoting can be preprocessed by the QRF without pivoting. That
*> well known trick is not used in CGEJSV because in some cases heavy row
*> weighting can be treated with complete pivoting. The overhead in cases
*>
*> The problem is solved in three steps:
*> (1) Reduce the coefficient matrix A to bidiagonal form with
-*> Householder tranformations, reducing the original problem
+*> Householder transformations, reducing the original problem
*> into a "bidiagonal least squares problem" (BLS)
*> (2) Solve the BLS using a divide and conquer approach.
-*> (3) Apply back all the Householder tranformations to solve
+*> (3) Apply back all the Householder transformations to solve
*> the original least squares problem.
*>
*> The effective rank of A is determined by treating as zero those
*> (LDA,N) if SIDE = 'L' or (LDA,K) if SIDE = 'R'
*> On entry, the K-by-N or M-by-K matrix A.
*> On exit, A is overwritten by the corresponding block of
-*> H*C or H**H*C or C*H or C*H**H. See Futher Details.
+*> H*C or H**H*C or C*H or C*H**H. See Further Details.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*> INFO is INTEGER
*> < 0 : if INFO = -i, then the i-th argument had an illegal value.
-*> = 0 : successfull exit;
+*> = 0 : successful exit;
*> > 0 : DGEJSV did not converge in the maximal allowed number
*> of sweeps. The computed values may be inaccurate.
*> \endverbatim
*> implemented as in [3]. We have a new version of DGEQP3 under development
*> that is more robust than the current one in LAPACK, with a cleaner cut in
*> rank defficient cases. It will be available in the SIGMA library [4].
-*> If M is much larger than N, it is obvious that the inital QRF with
+*> If M is much larger than N, it is obvious that the initial QRF with
*> column pivoting can be preprocessed by the QRF without pivoting. That
*> well known trick is not used in DGEJSV because in some cases heavy row
*> weighting can be treated with complete pivoting. The overhead in cases
*> Householder transformations, reducing the original problem
*> into a "bidiagonal least squares problem" (BLS)
*> (2) Solve the BLS using a divide and conquer approach.
-*> (3) Apply back all the Householder tranformations to solve
+*> (3) Apply back all the Householder transformations to solve
*> the original least squares problem.
*>
*> The effective rank of A is determined by treating as zero those
*>
*> RMAX is the overflow for the SINGLE PRECISION arithmetic
*> DLAG2S checks that all the entries of A are between -RMAX and
-*> RMAX. If not the convertion is aborted and a flag is raised.
+*> RMAX. If not the conversion is aborted and a flag is raised.
*>
*> This is an auxiliary routine so there is no argument checking.
*> \endverbatim
*>
*> RMAX is the overflow for the SINGLE PRECISION arithmetic
*> DLAS2S checks that all the entries of A are between -RMAX and
-*> RMAX. If not the convertion is aborted and a flag is raised.
+*> RMAX. If not the conversion is aborted and a flag is raised.
*>
*> This is an auxiliary routine so there is no argument checking.
*> \endverbatim
*> (LDA,N) if SIDE = 'L' or (LDA,K) if SIDE = 'R'
*> On entry, the K-by-N or M-by-K matrix A.
*> On exit, A is overwritten by the corresponding block of
-*> H*C or H**T*C or C*H or C*H**T. See Futher Details.
+*> H*C or H**T*C or C*H or C*H**T. See Further Details.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*> INFO is INTEGER
*> < 0 : if INFO = -i, then the i-th argument had an illegal value.
-*> = 0 : successfull exit;
+*> = 0 : successful exit;
*> > 0 : SGEJSV did not converge in the maximal allowed number
*> of sweeps. The computed values may be inaccurate.
*> \endverbatim
*> implemented as in [3]. We have a new version of SGEQP3 under development
*> that is more robust than the current one in LAPACK, with a cleaner cut in
*> rank defficient cases. It will be available in the SIGMA library [4].
-*> If M is much larger than N, it is obvious that the inital QRF with
+*> If M is much larger than N, it is obvious that the initial QRF with
*> column pivoting can be preprocessed by the QRF without pivoting. That
*> well known trick is not used in SGEJSV because in some cases heavy row
*> weighting can be treated with complete pivoting. The overhead in cases
*> Householder transformations, reducing the original problem
*> into a "bidiagonal least squares problem" (BLS)
*> (2) Solve the BLS using a divide and conquer approach.
-*> (3) Apply back all the Householder tranformations to solve
+*> (3) Apply back all the Householder transformations to solve
*> the original least squares problem.
*>
*> The effective rank of A is determined by treating as zero those
*> (LDA,N) if SIDE = 'L' or (LDA,K) if SIDE = 'R'
*> On entry, the K-by-N or M-by-K matrix A.
*> On exit, A is overwritten by the corresponding block of
-*> H*C or H^H*C or C*H or C*H^H. See Futher Details.
+*> H*C or H^H*C or C*H or C*H^H. See Further Details.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*> INFO is INTEGER
*> < 0 : if INFO = -i, then the i-th argument had an illegal value.
-*> = 0 : successfull exit;
+*> = 0 : successful exit;
*> > 0 : ZGEJSV did not converge in the maximal allowed number
*> of sweeps. The computed values may be inaccurate.
*> \endverbatim
*> implemented as in [3]. We have a new version of ZGEQP3 under development
*> that is more robust than the current one in LAPACK, with a cleaner cut in
*> rank defficient cases. It will be available in the SIGMA library [4].
-*> If M is much larger than N, it is obvious that the inital QRF with
+*> If M is much larger than N, it is obvious that the initial QRF with
*> column pivoting can be preprocessed by the QRF without pivoting. That
*> well known trick is not used in ZGEJSV because in some cases heavy row
*> weighting can be treated with complete pivoting. The overhead in cases
*>
*> The problem is solved in three steps:
*> (1) Reduce the coefficient matrix A to bidiagonal form with
-*> Householder tranformations, reducing the original problem
+*> Householder transformations, reducing the original problem
*> into a "bidiagonal least squares problem" (BLS)
*> (2) Solve the BLS using a divide and conquer approach.
-*> (3) Apply back all the Householder tranformations to solve
+*> (3) Apply back all the Householder transformations to solve
*> the original least squares problem.
*>
*> The effective rank of A is determined by treating as zero those
*>
*> RMAX is the overflow for the SINGLE PRECISION arithmetic
*> ZLAG2C checks that all the entries of A are between -RMAX and
-*> RMAX. If not the convertion is aborted and a flag is raised.
+*> RMAX. If not the conversion is aborted and a flag is raised.
*>
*> This is an auxiliary routine so there is no argument checking.
*> \endverbatim
*>
*> RMAX is the overflow for the SINGLE PRECISION arithmetic
*> ZLAT2C checks that all the entries of A are between -RMAX and
-*> RMAX. If not the convertion is aborted and a flag is raised.
+*> RMAX. If not the conversion is aborted and a flag is raised.
*>
*> This is an auxiliary routine so there is no argument checking.
*> \endverbatim
*> (LDA,N) if SIDE = 'L' or (LDA,K) if SIDE = 'R'
*> On entry, the K-by-N or M-by-K matrix A.
*> On exit, A is overwritten by the corresponding block of
-*> H*C or H**H*C or C*H or C*H**H. See Futher Details.
+*> H*C or H**H*C or C*H or C*H**H. See Further Details.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*>
*> CCHKBK tests CGEBAK, a routine for backward transformation of
-*> the computed right or left eigenvectors if the orginal matrix
+*> the computed right or left eigenvectors if the original matrix
*> was preprocessed by balance subroutine CGEBAL.
*> \endverbatim
*
*> \verbatim
*>
*> DCHKBK tests DGEBAK, a routine for backward transformation of
-*> the computed right or left eigenvectors if the orginal matrix
+*> the computed right or left eigenvectors if the original matrix
*> was preprocessed by balance subroutine DGEBAL.
*> \endverbatim
*
*> \verbatim
*>
*> SCHKBK tests SGEBAK, a routine for backward transformation of
-*> the computed right or left eigenvectors if the orginal matrix
+*> the computed right or left eigenvectors if the original matrix
*> was preprocessed by balance subroutine SGEBAL.
*> \endverbatim
*
*> \verbatim
*>
*> ZCHKBK tests ZGEBAK, a routine for backward transformation of
-*> the computed right or left eigenvectors if the orginal matrix
+*> the computed right or left eigenvectors if the original matrix
*> was preprocessed by balance subroutine ZGEBAL.
*> \endverbatim
*
CALL CDRVRF1( NOUT, NN, NVAL, THRESH, WORKA, NMAX, WORKARF,
+ S_WORK_CLANHE )
*
-* Test the convertion routines:
+* Test the conversion routines:
* chfttp, ctpthf, ctfttr, ctrttf, ctrttp and ctpttr.
*
CALL CDRVRF2( NOUT, NN, NVAL, WORKA, NMAX, WORKARF,
*>
*> \verbatim
*>
-*> CDRVRF2 tests the LAPACK RFP convertion routines.
+*> CDRVRF2 tests the LAPACK RFP conversion routines.
*> \endverbatim
*
* Arguments:
WRITE( NOUT, FMT = 9996 ) NERRS, NRUN
END IF
*
- 9999 FORMAT( 1X, ' *** Error(s) while testing the RFP convertion',
+ 9999 FORMAT( 1X, ' *** Error(s) while testing the RFP conversion',
+ ' routines ***')
- 9998 FORMAT( 1X, ' Error in RFP,convertion routines N=',I5,
+ 9998 FORMAT( 1X, ' Error in RFP,conversion routines N=',I5,
+ ' UPLO=''', A1, ''', FORM =''',A1,'''')
- 9997 FORMAT( 1X, 'All tests for the RFP convertion routines passed ( ',
+ 9997 FORMAT( 1X, 'All tests for the RFP conversion routines passed ( ',
+ I5,' tests run)')
- 9996 FORMAT( 1X, 'RFP convertion routines: ',I5,' out of ',I5,
+ 9996 FORMAT( 1X, 'RFP conversion routines: ',I5,' out of ',I5,
+ ' error message recorded')
*
RETURN
*> This testing routine follow the same tests as CDRVPO (test for the full
*> format Symmetric Positive Definite solver).
*>
-*> The tests are performed in Full Format, convertion back and forth from
+*> The tests are performed in Full Format, conversion back and forth from
*> full format to RFP format are performed using the routines CTRTTF and
*> CTFTTR.
*>
CALL DDRVRF1( NOUT, NN, NVAL, THRESH, WORKA, NMAX, WORKARF,
+ D_WORK_DLANSY )
*
-* Test the convertion routines:
+* Test the conversion routines:
* dtfttp, dtpttf, dtfttr, dtrttf, dtrttp and dtpttr.
*
CALL DDRVRF2( NOUT, NN, NVAL, WORKA, NMAX, WORKARF,
*>
*> \verbatim
*>
-*> DDRVRF2 tests the LAPACK RFP convertion routines.
+*> DDRVRF2 tests the LAPACK RFP conversion routines.
*> \endverbatim
*
* Arguments:
WRITE( NOUT, FMT = 9996 ) NERRS, NRUN
END IF
*
- 9999 FORMAT( 1X, ' *** Error(s) while testing the RFP convertion',
+ 9999 FORMAT( 1X, ' *** Error(s) while testing the RFP conversion',
+ ' routines ***')
- 9998 FORMAT( 1X, ' Error in RFP,convertion routines N=',I5,
+ 9998 FORMAT( 1X, ' Error in RFP,conversion routines N=',I5,
+ ' UPLO=''', A1, ''', FORM =''',A1,'''')
- 9997 FORMAT( 1X, 'All tests for the RFP convertion routines passed ( ',
+ 9997 FORMAT( 1X, 'All tests for the RFP conversion routines passed ( ',
+ I5,' tests run)')
- 9996 FORMAT( 1X, 'RFP convertion routines: ',I5,' out of ',I5,
+ 9996 FORMAT( 1X, 'RFP conversion routines: ',I5,' out of ',I5,
+ ' error message recorded')
*
RETURN
*> This testing routine follow the same tests as DDRVPO (test for the full
*> format Symmetric Positive Definite solver).
*>
-*> The tests are performed in Full Format, convertion back and forth from
+*> The tests are performed in Full Format, conversion back and forth from
*> full format to RFP format are performed using the routines DTRTTF and
*> DTFTTR.
*>
CALL SDRVRF1( NOUT, NN, NVAL, THRESH, WORKA, NMAX, WORKARF,
+ S_WORK_SLANSY )
*
-* Test the convertion routines:
+* Test the conversion routines:
* stfttp, stpttf, stfttr, strttf, strttp and stpttr.
*
CALL SDRVRF2( NOUT, NN, NVAL, WORKA, NMAX, WORKARF,
*>
*> \verbatim
*>
-*> SDRVRF2 tests the LAPACK RFP convertion routines.
+*> SDRVRF2 tests the LAPACK RFP conversion routines.
*> \endverbatim
*
* Arguments:
WRITE( NOUT, FMT = 9996 ) NERRS, NRUN
END IF
*
- 9999 FORMAT( 1X, ' *** Error(s) while testing the RFP convertion',
+ 9999 FORMAT( 1X, ' *** Error(s) while testing the RFP conversion',
+ ' routines ***')
- 9998 FORMAT( 1X, ' Error in RFP,convertion routines N=',I5,
+ 9998 FORMAT( 1X, ' Error in RFP,conversion routines N=',I5,
+ ' UPLO=''', A1, ''', FORM =''',A1,'''')
- 9997 FORMAT( 1X, 'All tests for the RFP convertion routines passed ( ',
+ 9997 FORMAT( 1X, 'All tests for the RFP conversion routines passed ( ',
+ I5,' tests run)')
- 9996 FORMAT( 1X, 'RFP convertion routines: ',I5,' out of ',I5,
+ 9996 FORMAT( 1X, 'RFP conversion routines: ',I5,' out of ',I5,
+ ' error message recorded')
*
RETURN
*> This testing routine follow the same tests as DDRVPO (test for the full
*> format Symmetric Positive Definite solver).
*>
-*> The tests are performed in Full Format, convertion back and forth from
+*> The tests are performed in Full Format, conversion back and forth from
*> full format to RFP format are performed using the routines STRTTF and
*> STFTTR.
*>
CALL ZDRVRF1( NOUT, NN, NVAL, THRESH, WORKA, NMAX, WORKARF,
+ D_WORK_ZLANHE )
*
-* Test the convertion routines:
+* Test the conversion routines:
* zhfttp, ztpthf, ztfttr, ztrttf, ztrttp and ztpttr.
*
CALL ZDRVRF2( NOUT, NN, NVAL, WORKA, NMAX, WORKARF,
*>
*> \verbatim
*>
-*> ZDRVRF2 tests the LAPACK RFP convertion routines.
+*> ZDRVRF2 tests the LAPACK RFP conversion routines.
*> \endverbatim
*
* Arguments:
WRITE( NOUT, FMT = 9996 ) NERRS, NRUN
END IF
*
- 9999 FORMAT( 1X, ' *** Error(s) while testing the RFP convertion',
+ 9999 FORMAT( 1X, ' *** Error(s) while testing the RFP conversion',
+ ' routines ***')
- 9998 FORMAT( 1X, ' Error in RFP,convertion routines N=',I5,
+ 9998 FORMAT( 1X, ' Error in RFP,conversion routines N=',I5,
+ ' UPLO=''', A1, ''', FORM =''',A1,'''')
- 9997 FORMAT( 1X, 'All tests for the RFP convertion routines passed (',
+ 9997 FORMAT( 1X, 'All tests for the RFP conversion routines passed (',
+ I5,' tests run)')
- 9996 FORMAT( 1X, 'RFP convertion routines:',I5,' out of ',I5,
+ 9996 FORMAT( 1X, 'RFP conversion routines:',I5,' out of ',I5,
+ ' error message recorded')
*
RETURN
*> This testing routine follow the same tests as ZDRVPO (test for the full
*> format Symmetric Positive Definite solver).
*>
-*> The tests are performed in Full Format, convertion back and forth from
+*> The tests are performed in Full Format, conversion back and forth from
*> full format to RFP format are performed using the routines ZTRTTF and
*> ZTFTTR.
*>
*> columns will be orthogonal, the remaining columns being
*> zero.
*> For matrices where M > N, just use the previous
-*> explaination, interchanging 'L' and 'R' and "rows" and
+*> explanation, interchanging 'L' and 'R' and "rows" and
*> "columns".
*>
*> Not modified.
*> \verbatim
*> PRTYPE is INTEGER
*> "Points" to a certain type of the matrices to generate
-*> (see futher details).
+*> (see further details).
*> \endverbatim
*>
*> \param[in] M
*> \param[in] TYPE
*> \verbatim
*> TYPE is INTEGER
-*> Specifies the problem type (see futher details).
+*> Specifies the problem type (see further details).
*> \endverbatim
*>
*> \param[in] N
*> \verbatim
*> PRTYPE is INTEGER
*> "Points" to a certain type of the matrices to generate
-*> (see futher details).
+*> (see further details).
*> \endverbatim
*>
*> \param[in] M
*> \param[in] TYPE
*> \verbatim
*> TYPE is INTEGER
-*> Specifies the problem type (see futher details).
+*> Specifies the problem type (see further details).
*> \endverbatim
*>
*> \param[in] N
*> \verbatim
*> PRTYPE is INTEGER
*> "Points" to a certain type of the matrices to generate
-*> (see futher details).
+*> (see further details).
*> \endverbatim
*>
*> \param[in] M
*> \param[in] TYPE
*> \verbatim
*> TYPE is INTEGER
-*> Specifies the problem type (see futher details).
+*> Specifies the problem type (see further details).
*> \endverbatim
*>
*> \param[in] N
*> \verbatim
*> PRTYPE is INTEGER
*> "Points" to a certain type of the matrices to generate
-*> (see futher details).
+*> (see further details).
*> \endverbatim
*>
*> \param[in] M
*> \param[in] TYPE
*> \verbatim
*> TYPE is INTEGER
-*> Specifies the problem type (see futher details).
+*> Specifies the problem type (see further details).
*> \endverbatim
*>
*> \param[in] N
projects / platform / upstream / lapack.git / commitdiff