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

Diff for /rpl/lapack/lapack/zunmqr.f between versions 1.3 and 1.17

version 1.3, 2010/08/06 15:29:03 version 1.17, 2017/06/17 10:54:34
Line 1 Line 1
   *> \brief \b ZUNMQR
   *
   *  =========== DOCUMENTATION ===========
   *
   * Online html documentation available at
   *            http://www.netlib.org/lapack/explore-html/
   *
   *> \htmlonly
   *> Download ZUNMQR + dependencies
   *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zunmqr.f">
   *> [TGZ]</a>
   *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zunmqr.f">
   *> [ZIP]</a>
   *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmqr.f">
   *> [TXT]</a>
   *> \endhtmlonly
   *
   *  Definition:
   *  ===========
   *
   *       SUBROUTINE ZUNMQR( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,
   *                          WORK, LWORK, INFO )
   *
   *       .. Scalar Arguments ..
   *       CHARACTER          SIDE, TRANS
   *       INTEGER            INFO, K, LDA, LDC, LWORK, M, N
   *       ..
   *       .. Array Arguments ..
   *       COMPLEX*16         A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )
   *       ..
   *
   *
   *> \par Purpose:
   *  =============
   *>
   *> \verbatim
   *>
   *> ZUNMQR overwrites the general complex M-by-N matrix C with
   *>
   *>                 SIDE = 'L'     SIDE = 'R'
   *> TRANS = 'N':      Q * C          C * Q
   *> TRANS = 'C':      Q**H * C       C * Q**H
   *>
   *> where Q is a complex unitary matrix defined as the product of k
   *> elementary reflectors
   *>
   *>       Q = H(1) H(2) . . . H(k)
   *>
   *> as returned by ZGEQRF. Q is of order M if SIDE = 'L' and of order N
   *> if SIDE = 'R'.
   *> \endverbatim
   *
   *  Arguments:
   *  ==========
   *
   *> \param[in] SIDE
   *> \verbatim
   *>          SIDE is CHARACTER*1
   *>          = 'L': apply Q or Q**H from the Left;
   *>          = 'R': apply Q or Q**H from the Right.
   *> \endverbatim
   *>
   *> \param[in] TRANS
   *> \verbatim
   *>          TRANS is CHARACTER*1
   *>          = 'N':  No transpose, apply Q;
   *>          = 'C':  Conjugate transpose, apply Q**H.
   *> \endverbatim
   *>
   *> \param[in] M
   *> \verbatim
   *>          M is INTEGER
   *>          The number of rows of the matrix C. M >= 0.
   *> \endverbatim
   *>
   *> \param[in] N
   *> \verbatim
   *>          N is INTEGER
   *>          The number of columns of the matrix C. N >= 0.
   *> \endverbatim
   *>
   *> \param[in] K
   *> \verbatim
   *>          K is INTEGER
   *>          The number of elementary reflectors whose product defines
   *>          the matrix Q.
   *>          If SIDE = 'L', M >= K >= 0;
   *>          if SIDE = 'R', N >= K >= 0.
   *> \endverbatim
   *>
   *> \param[in] A
   *> \verbatim
   *>          A is COMPLEX*16 array, dimension (LDA,K)
   *>          The i-th column must contain the vector which defines the
   *>          elementary reflector H(i), for i = 1,2,...,k, as returned by
   *>          ZGEQRF in the first k columns of its array argument A.
   *> \endverbatim
   *>
   *> \param[in] LDA
   *> \verbatim
   *>          LDA is INTEGER
   *>          The leading dimension of the array A.
   *>          If SIDE = 'L', LDA >= max(1,M);
   *>          if SIDE = 'R', LDA >= max(1,N).
   *> \endverbatim
   *>
   *> \param[in] TAU
   *> \verbatim
   *>          TAU is COMPLEX*16 array, dimension (K)
   *>          TAU(i) must contain the scalar factor of the elementary
   *>          reflector H(i), as returned by ZGEQRF.
   *> \endverbatim
   *>
   *> \param[in,out] C
   *> \verbatim
   *>          C is COMPLEX*16 array, dimension (LDC,N)
   *>          On entry, the M-by-N matrix C.
   *>          On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
   *> \endverbatim
   *>
   *> \param[in] LDC
   *> \verbatim
   *>          LDC is INTEGER
   *>          The leading dimension of the array C. LDC >= max(1,M).
   *> \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.
   *>          If SIDE = 'L', LWORK >= max(1,N);
   *>          if SIDE = 'R', LWORK >= max(1,M).
   *>          For good performance, LWORK should generally be larger.
   *>
   *>          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.
   *
   *> \date December 2016
   *
   *> \ingroup complex16OTHERcomputational
   *
   *  =====================================================================
       SUBROUTINE ZUNMQR( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,        SUBROUTINE ZUNMQR( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,
      $                   WORK, LWORK, INFO )       $                   WORK, LWORK, INFO )
 *  *
 *  -- LAPACK routine (version 3.2) --  *  -- LAPACK computational routine (version 3.7.0) --
 *  -- 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  *     December 2016
 *  *
 *     .. Scalar Arguments ..  *     .. Scalar Arguments ..
       CHARACTER          SIDE, TRANS        CHARACTER          SIDE, TRANS
Line 14 Line 180
       COMPLEX*16         A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )        COMPLEX*16         A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )
 *     ..  *     ..
 *  *
 *  Purpose  
 *  =======  
 *  
 *  ZUNMQR overwrites the general complex M-by-N matrix C with  
 *  
 *                  SIDE = 'L'     SIDE = 'R'  
 *  TRANS = 'N':      Q * C          C * Q  
 *  TRANS = 'C':      Q**H * C       C * Q**H  
 *  
 *  where Q is a complex unitary matrix defined as the product of k  
 *  elementary reflectors  
 *  
 *        Q = H(1) H(2) . . . H(k)  
 *  
 *  as returned by ZGEQRF. Q is of order M if SIDE = 'L' and of order N  
 *  if SIDE = 'R'.  
 *  
 *  Arguments  
 *  =========  
 *  
 *  SIDE    (input) CHARACTER*1  
 *          = 'L': apply Q or Q**H from the Left;  
 *          = 'R': apply Q or Q**H from the Right.  
 *  
 *  TRANS   (input) CHARACTER*1  
 *          = 'N':  No transpose, apply Q;  
 *          = 'C':  Conjugate transpose, apply Q**H.  
 *  
 *  M       (input) INTEGER  
 *          The number of rows of the matrix C. M >= 0.  
 *  
 *  N       (input) INTEGER  
 *          The number of columns of the matrix C. N >= 0.  
 *  
 *  K       (input) INTEGER  
 *          The number of elementary reflectors whose product defines  
 *          the matrix Q.  
 *          If SIDE = 'L', M >= K >= 0;  
 *          if SIDE = 'R', N >= K >= 0.  
 *  
 *  A       (input) COMPLEX*16 array, dimension (LDA,K)  
 *          The i-th column must contain the vector which defines the  
 *          elementary reflector H(i), for i = 1,2,...,k, as returned by  
 *          ZGEQRF in the first k columns of its array argument A.  
 *          A is modified by the routine but restored on exit.  
 *  
 *  LDA     (input) INTEGER  
 *          The leading dimension of the array A.  
 *          If SIDE = 'L', LDA >= max(1,M);  
 *          if SIDE = 'R', LDA >= max(1,N).  
 *  
 *  TAU     (input) COMPLEX*16 array, dimension (K)  
 *          TAU(i) must contain the scalar factor of the elementary  
 *          reflector H(i), as returned by ZGEQRF.  
 *  
 *  C       (input/output) COMPLEX*16 array, dimension (LDC,N)  
 *          On entry, the M-by-N matrix C.  
 *          On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.  
 *  
 *  LDC     (input) INTEGER  
 *          The leading dimension of the array C. LDC >= max(1,M).  
 *  
 *  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.  
 *          If SIDE = 'L', LWORK >= max(1,N);  
 *          if SIDE = 'R', LWORK >= max(1,M).  
 *          For optimum performance LWORK >= N*NB if SIDE = 'L', and  
 *          LWORK >= M*NB if SIDE = 'R', 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 ..
       INTEGER            NBMAX, LDT        INTEGER            NBMAX, LDT, TSIZE
       PARAMETER          ( NBMAX = 64, LDT = NBMAX+1 )        PARAMETER          ( NBMAX = 64, LDT = NBMAX+1,
        $                     TSIZE = LDT*NBMAX )
 *     ..  *     ..
 *     .. Local Scalars ..  *     .. Local Scalars ..
       LOGICAL            LEFT, LQUERY, NOTRAN        LOGICAL            LEFT, LQUERY, NOTRAN
       INTEGER            I, I1, I2, I3, IB, IC, IINFO, IWS, JC, LDWORK,        INTEGER            I, I1, I2, I3, IB, IC, IINFO, IWT, JC, LDWORK,
      $                   LWKOPT, MI, NB, NBMIN, NI, NQ, NW       $                   LWKOPT, MI, NB, NBMIN, NI, NQ, NW
 *     ..  *     ..
 *     .. Local Arrays ..  
       COMPLEX*16         T( LDT, NBMAX )  
 *     ..  
 *     .. External Functions ..  *     .. External Functions ..
       LOGICAL            LSAME        LOGICAL            LSAME
       INTEGER            ILAENV        INTEGER            ILAENV
Line 159 Line 241
 *  *
       IF( INFO.EQ.0 ) THEN        IF( INFO.EQ.0 ) THEN
 *  *
 *        Determine the block size.  NB may be at most NBMAX, where NBMAX  *        Compute the workspace requirements
 *        is used to define the local array T.  
 *  *
          NB = MIN( NBMAX, ILAENV( 1, 'ZUNMQR', SIDE // TRANS, M, N, K,           NB = MIN( NBMAX, ILAENV( 1, 'ZUNMQR', SIDE // TRANS, M, N, K,
      $        -1 ) )       $        -1 ) )
          LWKOPT = MAX( 1, NW )*NB           LWKOPT = MAX( 1, NW )*NB + TSIZE
          WORK( 1 ) = LWKOPT           WORK( 1 ) = LWKOPT
       END IF        END IF
 *  *
Line 185 Line 266
       NBMIN = 2        NBMIN = 2
       LDWORK = NW        LDWORK = NW
       IF( NB.GT.1 .AND. NB.LT.K ) THEN        IF( NB.GT.1 .AND. NB.LT.K ) THEN
          IWS = NW*NB           IF( LWORK.LT.NW*NB+TSIZE ) THEN
          IF( LWORK.LT.IWS ) THEN              NB = (LWORK-TSIZE) / LDWORK
             NB = LWORK / LDWORK  
             NBMIN = MAX( 2, ILAENV( 2, 'ZUNMQR', SIDE // TRANS, M, N, K,              NBMIN = MAX( 2, ILAENV( 2, 'ZUNMQR', SIDE // TRANS, M, N, K,
      $              -1 ) )       $              -1 ) )
          END IF           END IF
       ELSE  
          IWS = NW  
       END IF        END IF
 *  *
       IF( NB.LT.NBMIN .OR. NB.GE.K ) THEN        IF( NB.LT.NBMIN .OR. NB.GE.K ) THEN
Line 205 Line 283
 *  *
 *        Use blocked code  *        Use blocked code
 *  *
            IWT = 1 + NW*NB
          IF( ( LEFT .AND. .NOT.NOTRAN ) .OR.           IF( ( LEFT .AND. .NOT.NOTRAN ) .OR.
      $       ( .NOT.LEFT .AND. NOTRAN ) ) THEN       $       ( .NOT.LEFT .AND. NOTRAN ) ) THEN
             I1 = 1              I1 = 1
Line 231 Line 310
 *           H = H(i) H(i+1) . . . H(i+ib-1)  *           H = H(i) H(i+1) . . . H(i+ib-1)
 *  *
             CALL ZLARFT( 'Forward', 'Columnwise', NQ-I+1, IB, A( I, I ),              CALL ZLARFT( 'Forward', 'Columnwise', NQ-I+1, IB, A( I, I ),
      $                   LDA, TAU( I ), T, LDT )       $                   LDA, TAU( I ), WORK( IWT ), LDT )
             IF( LEFT ) THEN              IF( LEFT ) THEN
 *  *
 *              H or H' is applied to C(i:m,1:n)  *              H or H**H is applied to C(i:m,1:n)
 *  *
                MI = M - I + 1                 MI = M - I + 1
                IC = I                 IC = I
             ELSE              ELSE
 *  *
 *              H or H' is applied to C(1:m,i:n)  *              H or H**H is applied to C(1:m,i:n)
 *  *
                NI = N - I + 1                 NI = N - I + 1
                JC = I                 JC = I
             END IF              END IF
 *  *
 *           Apply H or H'  *           Apply H or H**H
 *  *
             CALL ZLARFB( SIDE, TRANS, 'Forward', 'Columnwise', MI, NI,              CALL ZLARFB( SIDE, TRANS, 'Forward', 'Columnwise', MI, NI,
      $                   IB, A( I, I ), LDA, T, LDT, C( IC, JC ), LDC,       $                   IB, A( I, I ), LDA, WORK( IWT ), LDT,
      $                   WORK, LDWORK )       $                   C( IC, JC ), LDC, WORK, LDWORK )
    10    CONTINUE     10    CONTINUE
       END IF        END IF
       WORK( 1 ) = LWKOPT        WORK( 1 ) = LWKOPT
Removed from v.1.3  
changed lines
  Added in v.1.17

CVSweb interface <joel.bertrand@systella.fr>