[BACK]Return to zungbr.f CVS log [TXT] [DIR] Up to [local] / rpl / lapack / lapack

Diff for /rpl/lapack/lapack/zungbr.f between versions 1.2 and 1.19

version 1.2, 2010/04/21 13:45:41 version 1.19, 2023/08/07 08:39:43
Line 1 Line 1
   *> \brief \b ZUNGBR
   *
   *  =========== DOCUMENTATION ===========
   *
   * Online html documentation available at
   *            http://www.netlib.org/lapack/explore-html/
   *
   *> \htmlonly
   *> Download ZUNGBR + dependencies
   *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zungbr.f">
   *> [TGZ]</a>
   *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zungbr.f">
   *> [ZIP]</a>
   *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungbr.f">
   *> [TXT]</a>
   *> \endhtmlonly
   *
   *  Definition:
   *  ===========
   *
   *       SUBROUTINE ZUNGBR( VECT, M, N, K, A, LDA, TAU, WORK, LWORK, INFO )
   *
   *       .. Scalar Arguments ..
   *       CHARACTER          VECT
   *       INTEGER            INFO, K, LDA, LWORK, M, N
   *       ..
   *       .. Array Arguments ..
   *       COMPLEX*16         A( LDA, * ), TAU( * ), WORK( * )
   *       ..
   *
   *
   *> \par Purpose:
   *  =============
   *>
   *> \verbatim
   *>
   *> ZUNGBR generates one of the complex unitary matrices Q or P**H
   *> determined by ZGEBRD when reducing a complex matrix A to bidiagonal
   *> form: A = Q * B * P**H.  Q and P**H are defined as products of
   *> elementary reflectors H(i) or G(i) respectively.
   *>
   *> If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q
   *> is of order M:
   *> if m >= k, Q = H(1) H(2) . . . H(k) and ZUNGBR returns the first n
   *> columns of Q, where m >= n >= k;
   *> if m < k, Q = H(1) H(2) . . . H(m-1) and ZUNGBR returns Q as an
   *> M-by-M matrix.
   *>
   *> If VECT = 'P', A is assumed to have been a K-by-N matrix, and P**H
   *> is of order N:
   *> if k < n, P**H = G(k) . . . G(2) G(1) and ZUNGBR returns the first m
   *> rows of P**H, where n >= m >= k;
   *> if k >= n, P**H = G(n-1) . . . G(2) G(1) and ZUNGBR returns P**H as
   *> an N-by-N matrix.
   *> \endverbatim
   *
   *  Arguments:
   *  ==========
   *
   *> \param[in] VECT
   *> \verbatim
   *>          VECT is CHARACTER*1
   *>          Specifies whether the matrix Q or the matrix P**H is
   *>          required, as defined in the transformation applied by ZGEBRD:
   *>          = 'Q':  generate Q;
   *>          = 'P':  generate P**H.
   *> \endverbatim
   *>
   *> \param[in] M
   *> \verbatim
   *>          M is INTEGER
   *>          The number of rows of the matrix Q or P**H to be returned.
   *>          M >= 0.
   *> \endverbatim
   *>
   *> \param[in] N
   *> \verbatim
   *>          N is INTEGER
   *>          The number of columns of the matrix Q or P**H to be returned.
   *>          N >= 0.
   *>          If VECT = 'Q', M >= N >= min(M,K);
   *>          if VECT = 'P', N >= M >= min(N,K).
   *> \endverbatim
   *>
   *> \param[in] K
   *> \verbatim
   *>          K is INTEGER
   *>          If VECT = 'Q', the number of columns in the original M-by-K
   *>          matrix reduced by ZGEBRD.
   *>          If VECT = 'P', the number of rows in the original K-by-N
   *>          matrix reduced by ZGEBRD.
   *>          K >= 0.
   *> \endverbatim
   *>
   *> \param[in,out] A
   *> \verbatim
   *>          A is COMPLEX*16 array, dimension (LDA,N)
   *>          On entry, the vectors which define the elementary reflectors,
   *>          as returned by ZGEBRD.
   *>          On exit, the M-by-N matrix Q or P**H.
   *> \endverbatim
   *>
   *> \param[in] LDA
   *> \verbatim
   *>          LDA is INTEGER
   *>          The leading dimension of the array A. LDA >= M.
   *> \endverbatim
   *>
   *> \param[in] TAU
   *> \verbatim
   *>          TAU is COMPLEX*16 array, dimension
   *>                                (min(M,K)) if VECT = 'Q'
   *>                                (min(N,K)) if VECT = 'P'
   *>          TAU(i) must contain the scalar factor of the elementary
   *>          reflector H(i) or G(i), which determines Q or P**H, as
   *>          returned by ZGEBRD in its array argument TAUQ or TAUP.
   *> \endverbatim
   *>
   *> \param[out] WORK
   *> \verbatim
   *>          WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))
   *>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
   *> \endverbatim
   *>
   *> \param[in] LWORK
   *> \verbatim
   *>          LWORK is INTEGER
   *>          The dimension of the array WORK. LWORK >= max(1,min(M,N)).
   *>          For optimum performance LWORK >= min(M,N)*NB, where NB
   *>          is the optimal blocksize.
   *>
   *>          If LWORK = -1, then a workspace query is assumed; the routine
   *>          only calculates the optimal size of the WORK array, returns
   *>          this value as the first entry of the WORK array, and no error
   *>          message related to LWORK is issued by XERBLA.
   *> \endverbatim
   *>
   *> \param[out] INFO
   *> \verbatim
   *>          INFO is INTEGER
   *>          = 0:  successful exit
   *>          < 0:  if INFO = -i, the i-th argument had an illegal value
   *> \endverbatim
   *
   *  Authors:
   *  ========
   *
   *> \author Univ. of Tennessee
   *> \author Univ. of California Berkeley
   *> \author Univ. of Colorado Denver
   *> \author NAG Ltd.
   *
   *> \ingroup complex16GBcomputational
   *
   *  =====================================================================
       SUBROUTINE ZUNGBR( VECT, M, N, K, A, LDA, TAU, WORK, LWORK, INFO )        SUBROUTINE ZUNGBR( VECT, M, N, K, A, LDA, TAU, WORK, LWORK, INFO )
 *  *
 *  -- LAPACK routine (version 3.2) --  *  -- LAPACK computational routine --
 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --  *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--  *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
 *     November 2006  
 *  *
 *     .. Scalar Arguments ..  *     .. Scalar Arguments ..
       CHARACTER          VECT        CHARACTER          VECT
Line 13 Line 167
       COMPLEX*16         A( LDA, * ), TAU( * ), WORK( * )        COMPLEX*16         A( LDA, * ), TAU( * ), WORK( * )
 *     ..  *     ..
 *  *
 *  Purpose  
 *  =======  
 *  
 *  ZUNGBR generates one of the complex unitary matrices Q or P**H  
 *  determined by ZGEBRD when reducing a complex matrix A to bidiagonal  
 *  form: A = Q * B * P**H.  Q and P**H are defined as products of  
 *  elementary reflectors H(i) or G(i) respectively.  
 *  
 *  If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q  
 *  is of order M:  
 *  if m >= k, Q = H(1) H(2) . . . H(k) and ZUNGBR returns the first n  
 *  columns of Q, where m >= n >= k;  
 *  if m < k, Q = H(1) H(2) . . . H(m-1) and ZUNGBR returns Q as an  
 *  M-by-M matrix.  
 *  
 *  If VECT = 'P', A is assumed to have been a K-by-N matrix, and P**H  
 *  is of order N:  
 *  if k < n, P**H = G(k) . . . G(2) G(1) and ZUNGBR returns the first m  
 *  rows of P**H, where n >= m >= k;  
 *  if k >= n, P**H = G(n-1) . . . G(2) G(1) and ZUNGBR returns P**H as  
 *  an N-by-N matrix.  
 *  
 *  Arguments  
 *  =========  
 *  
 *  VECT    (input) CHARACTER*1  
 *          Specifies whether the matrix Q or the matrix P**H is  
 *          required, as defined in the transformation applied by ZGEBRD:  
 *          = 'Q':  generate Q;  
 *          = 'P':  generate P**H.  
 *  
 *  M       (input) INTEGER  
 *          The number of rows of the matrix Q or P**H to be returned.  
 *          M >= 0.  
 *  
 *  N       (input) INTEGER  
 *          The number of columns of the matrix Q or P**H to be returned.  
 *          N >= 0.  
 *          If VECT = 'Q', M >= N >= min(M,K);  
 *          if VECT = 'P', N >= M >= min(N,K).  
 *  
 *  K       (input) INTEGER  
 *          If VECT = 'Q', the number of columns in the original M-by-K  
 *          matrix reduced by ZGEBRD.  
 *          If VECT = 'P', the number of rows in the original K-by-N  
 *          matrix reduced by ZGEBRD.  
 *          K >= 0.  
 *  
 *  A       (input/output) COMPLEX*16 array, dimension (LDA,N)  
 *          On entry, the vectors which define the elementary reflectors,  
 *          as returned by ZGEBRD.  
 *          On exit, the M-by-N matrix Q or P**H.  
 *  
 *  LDA     (input) INTEGER  
 *          The leading dimension of the array A. LDA >= M.  
 *  
 *  TAU     (input) COMPLEX*16 array, dimension  
 *                                (min(M,K)) if VECT = 'Q'  
 *                                (min(N,K)) if VECT = 'P'  
 *          TAU(i) must contain the scalar factor of the elementary  
 *          reflector H(i) or G(i), which determines Q or P**H, as  
 *          returned by ZGEBRD in its array argument TAUQ or TAUP.  
 *  
 *  WORK    (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK))  
 *          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.  
 *  
 *  LWORK   (input) INTEGER  
 *          The dimension of the array WORK. LWORK >= max(1,min(M,N)).  
 *          For optimum performance LWORK >= min(M,N)*NB, where NB  
 *          is the optimal blocksize.  
 *  
 *          If LWORK = -1, then a workspace query is assumed; the routine  
 *          only calculates the optimal size of the WORK array, returns  
 *          this value as the first entry of the WORK array, and no error  
 *          message related to LWORK is issued by XERBLA.  
 *  
 *  INFO    (output) INTEGER  
 *          = 0:  successful exit  
 *          < 0:  if INFO = -i, the i-th argument had an illegal value  
 *  
 *  =====================================================================  *  =====================================================================
 *  *
 *     .. Parameters ..  *     .. Parameters ..
Line 102 Line 176
 *     ..  *     ..
 *     .. Local Scalars ..  *     .. Local Scalars ..
       LOGICAL            LQUERY, WANTQ        LOGICAL            LQUERY, WANTQ
       INTEGER            I, IINFO, J, LWKOPT, MN, NB        INTEGER            I, IINFO, J, LWKOPT, MN
 *     ..  *     ..
 *     .. External Functions ..  *     .. External Functions ..
       LOGICAL            LSAME        LOGICAL            LSAME
       INTEGER            ILAENV        EXTERNAL           LSAME
       EXTERNAL           LSAME, ILAENV  
 *     ..  *     ..
 *     .. External Subroutines ..  *     .. External Subroutines ..
       EXTERNAL           XERBLA, ZUNGLQ, ZUNGQR        EXTERNAL           XERBLA, ZUNGLQ, ZUNGQR
Line 140 Line 213
       END IF        END IF
 *  *
       IF( INFO.EQ.0 ) THEN        IF( INFO.EQ.0 ) THEN
            WORK( 1 ) = 1
          IF( WANTQ ) THEN           IF( WANTQ ) THEN
             NB = ILAENV( 1, 'ZUNGQR', ' ', M, N, K, -1 )              IF( M.GE.K ) THEN
                  CALL ZUNGQR( M, N, K, A, LDA, TAU, WORK, -1, IINFO )
               ELSE
                  IF( M.GT.1 ) THEN
                     CALL ZUNGQR( M-1, M-1, M-1, A, LDA, TAU, WORK, -1,
        $                         IINFO )
                  END IF
               END IF
          ELSE           ELSE
             NB = ILAENV( 1, 'ZUNGLQ', ' ', M, N, K, -1 )              IF( K.LT.N ) THEN
                  CALL ZUNGLQ( M, N, K, A, LDA, TAU, WORK, -1, IINFO )
               ELSE
                  IF( N.GT.1 ) THEN
                     CALL ZUNGLQ( N-1, N-1, N-1, A, LDA, TAU, WORK, -1,
        $                         IINFO )
                  END IF
               END IF
          END IF           END IF
          LWKOPT = MAX( 1, MN )*NB           LWKOPT = INT( DBLE( WORK( 1 ) ) )
          WORK( 1 ) = LWKOPT           LWKOPT = MAX (LWKOPT, MN)
       END IF        END IF
 *  *
       IF( INFO.NE.0 ) THEN        IF( INFO.NE.0 ) THEN
          CALL XERBLA( 'ZUNGBR', -INFO )           CALL XERBLA( 'ZUNGBR', -INFO )
          RETURN           RETURN
       ELSE IF( LQUERY ) THEN        ELSE IF( LQUERY ) THEN
            WORK( 1 ) = LWKOPT
          RETURN           RETURN
       END IF        END IF
 *  *
Line 202 Line 291
          END IF           END IF
       ELSE        ELSE
 *  *
 *        Form P', determined by a call to ZGEBRD to reduce a k-by-n  *        Form P**H, determined by a call to ZGEBRD to reduce a k-by-n
 *        matrix  *        matrix
 *  *
          IF( K.LT.N ) THEN           IF( K.LT.N ) THEN
Line 216 Line 305
 *           If k >= n, assume m = n  *           If k >= n, assume m = n
 *  *
 *           Shift the vectors which define the elementary reflectors one  *           Shift the vectors which define the elementary reflectors one
 *           row downward, and set the first row and column of P' to  *           row downward, and set the first row and column of P**H to
 *           those of the unit matrix  *           those of the unit matrix
 *  *
             A( 1, 1 ) = ONE              A( 1, 1 ) = ONE
Line 231 Line 320
    60       CONTINUE     60       CONTINUE
             IF( N.GT.1 ) THEN              IF( N.GT.1 ) THEN
 *  *
 *              Form P'(2:n,2:n)  *              Form P**H(2:n,2:n)
 *  *
                CALL ZUNGLQ( N-1, N-1, N-1, A( 2, 2 ), LDA, TAU, WORK,                 CALL ZUNGLQ( N-1, N-1, N-1, A( 2, 2 ), LDA, TAU, WORK,
      $                      LWORK, IINFO )       $                      LWORK, IINFO )
Removed from v.1.2  
changed lines
  Added in v.1.19

CVSweb interface <joel.bertrand@systella.fr>