Routine PZUNGRQ() Documented By Universal Report

Routine: PZUNGRQ()

# lines:	302
# code:	302
# comment:	0
# blank:	0
# Variables:	43
# Callers:	0
# Callings:	4
# Words:	122
# Keywords:	67

..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PZUNGRQ generates an M-by-N complex distributed matrix Q denoting
  A(IA:IA+M-1,JA:JA+N-1) with orthonormal rows, which is defined as the
  last M rows of a product of K elementary reflectors of order N
        Q  =  H(1)' H(2)' . . . H(k)'
  as returned by PZGERQF.
  Notes
  =====
  Each global data object is described by an associated description
  vector.  This vector stores the information required to establish
  the mapping between an object element and its corresponding process
  and memory location.
  Let A be a generic term for any 2D block cyclicly distributed array.
  Such a global array has an associated description vector DESCA.
  In the following comments, the character _ should be read as
  "of the global array".
  NOTATION        STORED IN      EXPLANATION
  --------------- -------------- --------------------------------------
  DTYPE_A(global) DESCA( DTYPE_ )The descriptor type.  In this case,
                                 DTYPE_A = 1.
  CTXT_A (global) DESCA( CTXT_ ) The BLACS context handle, indicating
                                 the BLACS process grid A is distribu-
                                 ted over. The context itself is glo-
                                 bal, but the handle (the integer
                                 value) may vary.
  M_A    (global) DESCA( M_ )    The number of rows in the global
                                 array A.
  N_A    (global) DESCA( N_ )    The number of columns in the global
                                 array A.
  MB_A   (global) DESCA( MB_ )   The blocking factor used to distribute
                                 the rows of the array.
  NB_A   (global) DESCA( NB_ )   The blocking factor used to distribute
                                 the columns of the array.
  RSRC_A (global) DESCA( RSRC_ ) The process row over which the first
                                 row of the array A is distributed.
  CSRC_A (global) DESCA( CSRC_ ) The process column over which the
                                 first column of the array A is
                                 distributed.
  LLD_A  (local)  DESCA( LLD_ )  The leading dimension of the local
                                 array.  LLD_A >= MAX(1,LOCr(M_A)).
  Let K be the number of rows or columns of a distributed matrix,
  and assume that its process grid has dimension p x q.
  LOCr( K ) denotes the number of elements of K that a process
  would receive if K were distributed over the p processes of its
  process column.
  Similarly, LOCc( K ) denotes the number of elements of K that a
  process would receive if K were distributed over the q processes of
  its process row.
  The values of LOCr() and LOCc() may be determined via a call to the
  ScaLAPACK tool function, NUMROC:
          LOCr( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
          LOCc( N ) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).
  An upper bound for these quantities may be computed by:
          LOCr( M ) <= ceil( ceil(M/MB_A)/NPROW )*MB_A
          LOCc( N ) <= ceil( ceil(N/NB_A)/NPCOL )*NB_A
  Arguments
  =========
  M       (global input) INTEGER
          The number of rows to be operated on i.e the number of rows
          of the distributed submatrix Q. M >= 0.
  N       (global input) INTEGER
          The number of columns to be operated on i.e the number of
          columns of the distributed submatrix Q.
          N >= M >= 0.
  K       (global input) INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q. M >= K >= 0.
  A       (local input/local output) COMPLEX*16 pointer into the
          local memory to an array of dimension (LLD_A,LOCc(JA+N-1)).
          On entry, the i-th row must contain the vector which defines
          the elementary reflector H(i), IA+M-K <= i <= IA+M-1, as
          returned by PZGERQF in the K rows of its distributed
          matrix argument A(IA+M-K:IA+M-1,JA:*). On exit, this array
          contains the local pieces of the M-by-N distributed matrix Q.
  IA      (global input) INTEGER
          The row index in the global array A indicating the first
          row of sub( A ).
  JA      (global input) INTEGER
          The column index in the global array A indicating the
          first column of sub( A ).
  DESCA   (global and local input) INTEGER array of dimension DLEN_.
          The array descriptor for the distributed matrix A.
  TAU     (local input) COMPLEX*16, array, dimension LOCr(IA+M-1)
          This array contains the scalar factors TAU(i) of the
          elementary reflectors H(i) as returned by PZGERQF.
          TAU is tied to the distributed matrix A.
  WORK    (local workspace/local output) COMPLEX*16 array,
                                                  dimension (LWORK)
          On exit, WORK(1) returns the minimal and optimal LWORK.
  LWORK   (local or global input) INTEGER
          The dimension of the array WORK.
          LWORK is local input and must be at least
          LWORK >= MB_A * ( MpA0 + NqA0 + MB_A ), where
          IROFFA = MOD( IA-1, MB_A ), ICOFFA = MOD( JA-1, NB_A ),
          IAROW = INDXG2P( IA, MB_A, MYROW, RSRC_A, NPROW ),
          IACOL = INDXG2P( JA, NB_A, MYCOL, CSRC_A, NPCOL ),
          MpA0 = NUMROC( M+IROFFA, MB_A, MYROW, IAROW, NPROW ),
          NqA0 = NUMROC( N+ICOFFA, NB_A, MYCOL, IACOL, NPCOL ),
          INDXG2P and NUMROC are ScaLAPACK tool functions;
          MYROW, MYCOL, NPROW and NPCOL can be determined by calling
          the subroutine BLACS_GRIDINFO.
          If LWORK = -1, then LWORK is global input and a workspace
          query is assumed; the routine only calculates the minimum
          and optimal size for all work arrays. Each of these
          values is returned in the first entry of the corresponding
          work array, and no error message is issued by PXERBLA.
  INFO    (global output) INTEGER
          = 0:  successful exit
          < 0:  If the i-th argument is an array and the j-entry had
                an illegal value, then INFO = -(i*100+j), if the i-th
                argument is a scalar and had an illegal value, then
                INFO = -i.
  =====================================================================
     .. Parameters ..

Display dynamic version

FontSize: - +

001        SUBROUTINE PZUNGRQ( M , N , K , A , IA , JA , DESCA , TAU , WORK , LWORK ,
002       $INFO )
003  
004  *     -- ScaLAPACK routine(version 1.7) --
005  *     University of Tennessee , Knoxville , Oak Ridge National Laboratory ,
006  *     and University of California , Berkeley.
007  *     May 25 , 2001
008  
009  *     .. Scalar Arguments ..
010        INTEGER IA , INFO , JA , K , LWORK , M , N
011        INTEGER BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ ,
012       $LLD_ , MB_ , M_ , NB_ , N_ , RSRC_
013        PARAMETER( BLOCK_CYCLIC_2D = 1 , DLEN_ = 9 , DTYPE_ = 1 ,
014       $CTXT_ = 2 , M_ = 3 , N_ = 4 , MB_ = 5 , NB_ = 6 ,
015       $RSRC_ = 7 , CSRC_ = 8 , LLD_ = 9 )
016        COMPLEX*16 ZERO
017        PARAMETER( ZERO =( 0.0D + 0 , 0.0D + 0 ) )
018  *     ..
019  *     .. Local Scalars ..
020        LOGICAL LQUERY
021        CHARACTER COLBTOP , ROWBTOP
022        INTEGER I , IACOL , IAROW , IB , ICTXT , IINFO , IN , IPW ,
023       $LWMIN , MPA0 , MYCOL , MYROW , NPCOL , NPROW , NQA0
024  *     ..
025  *     .. Local Arrays ..
026        INTEGER IDUM1( 2 ) , IDUM2( 2 )
027  *     ..
028  *     .. External Subroutines ..
029        EXTERNAL BLACS_GRIDINFO , CHK1MAT , PCHK1MAT , PB_TOPGET ,
030       $PB_TOPSET , PXERBLA , PZLARFB , PZLARFT ,
031       $PZLASET , PZUNGR2  
032  *     ..
033  *     .. External Functions ..
034        INTEGER ICEIL , INDXG2P , NUMROC
035        EXTERNAL ICEIL , INDXG2P , NUMROC
036  *     ..
037  *     .. Intrinsic Functions ..
038        INTRINSIC DBLE , DCMPLX , MIN , MOD
039  *     ..
040  *     .. Executable Statements ..
041  
042  *     Get grid parameters
043  
044        ICTXT = DESCA( CTXT_ )
045        CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
046  
047  *     Test the input parameters
048  
049        INFO = 0
050        IF( NPROW.EQ. - 1 ) THEN
050               
051            INFO = - (700 + CTXT_)
052        ELSE
052               
053            CALL CHK1MAT( M , 1 , N , 2 , IA , JA , DESCA , 7 , INFO )
054            IF( INFO.EQ.0 ) THEN
054                   
055                IAROW = INDXG2P( IA , DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) ,
056       $        NPROW )
057                IACOL = INDXG2P( JA , DESCA( NB_ ) , MYCOL , DESCA( CSRC_ ) ,
058       $        NPCOL )
059                MPA0 = NUMROC( M + MOD( IA - 1 , DESCA( MB_ ) ) , DESCA( MB_ ) ,
060       $        MYROW , IAROW , NPROW )
061                NQA0 = NUMROC( N + MOD( JA - 1 , DESCA( NB_ ) ) , DESCA( NB_ ) ,
062       $        MYCOL , IACOL , NPCOL )
063                LWMIN = DESCA( MB_ ) * ( MPA0 + NQA0 + DESCA( MB_ ) )
064  
065                WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )
066                LQUERY =( LWORK.EQ. - 1 )
067                IF( N.LT.M ) THEN
067                       
068                    INFO = - 2
069                ELSE IF( K.LT.0 .OR. K.GT.M ) THEN
069                       
070                    INFO = - 3
071                ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
071                       
072                    INFO = - 10
073                END IF
074            END IF
075            IDUM1( 1 ) = K
076            IDUM2( 1 ) = 3
077            IF( LWORK.EQ. - 1 ) THEN
077                   
078                IDUM1( 2 ) = - 1
079            ELSE
079                   
080                IDUM1( 2 ) = 1
081            END IF
082            IDUM2( 2 ) = 10
083            CALL PCHK1MAT( M , 1 , N , 2 , IA , JA , DESCA , 7 , 2 , IDUM1 , IDUM2 ,
084       $    INFO )
085        END IF
086  
087        IF( INFO.NE.0 ) THEN
087               
088            CALL PXERBLA( ICTXT , 'PZUNGRQ' , - INFO )
089            RETURN
090        ELSE IF( LQUERY ) THEN
090               
091            RETURN
092        END IF
093  
094  *     Quick return if possible
095  
096        IF( M.LE.0 )
096               
097       $    RETURN
098  
099            IPW = DESCA( MB_ )*DESCA( MB_ ) + 1
100            IN = MIN( ICEIL( IA + M - K , DESCA( MB_ ) )*DESCA( MB_ ) , IA + M - 1 )
101            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
102            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
103            CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , ' ' )
104            CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , 'I - ring' )
105  
106  *         Set A(ia : in , ja + n - m + in - ia + 1 : ja - n + 1) to zero.
107  
108            CALL PZLASET ( 'All' , IN - IA + 1 , M - IN + IA - 1 , ZERO , ZERO , A , IA ,
109       $    JA + N - M + IN - IA + 1 , DESCA )
110  
111  *         Use unblocked code for the first or only block.
112  
113            CALL PZUNGR2 ( IN - IA + 1 , N - M + IN - IA + 1 , IN - IA - M + K + 1 , A , IA , JA , DESCA ,
114       $    TAU , WORK , LWORK , IINFO )
115  
116  *         Use blocked code
117  
118            DO 10 I = IN + 1 , IA + M - 1 , DESCA( MB_ )
118                   
119                IB = MIN( IA + M - I , DESCA( MB_ ) )
120  
121  *             Form the triangular factor of the block reflector
122  *             H = H(i + ib - 1) . . . H(i + 1) H(i)
123  
124                CALL PZLARFT ( 'Backward' , 'Rowwise' , N - M + I + IB - IA , IB , A , I , JA ,
125       $        DESCA , TAU , WORK , WORK( IPW ) )
126  
127  *             Apply H' to A(ia : i - 1 , ja : ja + n - m + i + ib - ia - 1) from the right
128  
129                CALL PZLARFB ( 'Right' , 'Conjugate transpose' , 'Backward' ,
130       $        'Rowwise' , I - IA , N - M + I + IB - IA , IB , A , I , JA ,
131       $        DESCA , WORK , A , IA , JA , DESCA , WORK( IPW ) )
132  
133  *             Apply H' to columns ja : ja + n - m + i + ib - ia - 1 of current block
134  
135                CALL PZUNGR2 ( IB , N - M + I + IB - IA , IB , A , I , JA , DESCA , TAU , WORK ,
136       $        LWORK , IINFO )
137  
138  *             Set rows i : i + ib - 1 , ja + n - m + i + ib - ia : ja + n - 1 of current block to
139  *             zero
140  
141                CALL PZLASET ( 'All' , IB , M - I - IB + IA , ZERO , ZERO , A , I ,
142       $        JA + N - M + I + IB - IA , DESCA )
143  
144     10     CONTINUE
145  
145               
146            CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
147            CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
148  
149            WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )
150  
151            RETURN
152  
153  *         End of PZUNGRQ
154  
155        END3031

Variables in Routine PZUNGRQ()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	2	2
*COMPLEX16**	1	?
INTEGER	38	164
LOGICAL	1	1
REAL	1	4
TOTAL	43	171

List of Variables

CHARACTER

COLBTOP ROWBTOP

COMPLEX*16

ZERO

INTEGER

BLOCK_CYCLIC_2D CSRC_ CTXT_ DLEN_ DTYPE_
I IA IACOL IAROW IB
ICEIL ICTXT IDUM1( 2 ) IDUM2( 2 ) IINFO
IN INDXG2P INFO IPW JA
K LLD_ LWMIN LWORK M
M_ MB_ MPA0 MYCOL MYROW
N N_ NB_ NPCOL NPROW
NQA0 NUMROC RSRC_

LOGICAL

LQUERY

REAL

WORK

Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence
-
- -
I <--- INDO 10 I = IN+1, IA+M-1, DESCA( MB_ ), MDO 10 I = IN+1, IA+M-1, DESCA( MB_ ), MB_DO 10 I = IN+1, IA+M-1, DESCA( MB_ ), IADO 10 I = IN+1, IA+M-1, DESCA( MB_ )

IACOL <--- INDXG2P, JA, CSRC_, MYCOL, NB_, NPCOL

IAROW <--- INDXG2P, MB_, MYROW, NPROW, RSRC_, IA

IB <--- MIB = MIN( IA+M-I, DESCA( MB_ ) ), MB_IB = MIN( IA+M-I, DESCA( MB_ ) ), IIB = MIN( IA+M-I, DESCA( MB_ ) ), IAIB = MIN( IA+M-I, DESCA( MB_ ) )

ICTXT <--- CTXT_ICTXT = DESCA( CTXT_ )

IDUM1 <--- KIDUM1( 1 ) = K

IN <--- ICEIL, K, M, MB_, IA

INFO <--- CTXT_INFO = -(700+CTXT_)

IPW <--- MB_IPW = DESCA( MB_ )*DESCA( MB_ ) + 1

LWMIN <--- MB_, MPA0, NQA0

MPA0 <--- IAROW, M, MB_, MYROW, NPROW, NUMROC, IA

NQA0 <--- JA, MYCOL, N, NB_, NPCOL, NUMROC, IACOL

WORK <--- LWMINWORK( 1 ) = DCMPLX( DBLE( LWMIN ) ){2WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )}