Routine: PZUNMRZ()  File: SRC\pzunmrz.f

 
 
# lines: 479
  # code: 479
  # comment: 0
  # blank:0
# Variables:67
# Callers:0
# Callings:3
# Words:270
# Keywords:180
 

 

 
..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PZUNMRZ overwrites the general complex M-by-N distributed matrix
  sub( C ) = C(IC:IC+M-1,JC:JC+N-1) with
                       SIDE = 'L'           SIDE = 'R'
  TRANS = 'N':      Q * sub( C )          sub( C ) * Q
  TRANS = 'C':      Q**H * sub( C )       sub( C ) * Q**H
  where Q is a complex unitary distributed matrix defined as the
  product of K elementary reflectors
        Q = H(1)' H(2)' . . . H(k)'
  as returned by PZTZRZF. Q is of order M if SIDE = 'L' and of order N
  if SIDE = 'R'.
  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
  =========
  SIDE    (global input) CHARACTER
          = 'L': apply Q or Q**H from the Left;
          = 'R': apply Q or Q**H from the Right.
  TRANS   (global input) CHARACTER
          = 'N':  No transpose, apply Q;
          = 'C':  Conjugate transpose, apply Q**H.
  M       (global input) INTEGER
          The number of rows to be operated on i.e the number of rows
          of the distributed submatrix sub( C ). M >= 0.
  N       (global input) INTEGER
          The number of columns to be operated on i.e the number of
          columns of the distributed submatrix sub( C ). N >= 0.
  K       (global 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.
  L       (global input) INTEGER
          The columns of the distributed submatrix sub( A ) containing
          the meaningful part of the Householder reflectors.
          If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0.
  A       (local input) COMPLEX*16 pointer into the local memory
          to an array of dimension (LLD_A,LOCc(JA+M-1)) if SIDE='L',
          and (LLD_A,LOCc(JA+N-1)) if SIDE='R', where
          LLD_A >= MAX(1,LOCr(IA+K-1)); On entry, the i-th row must
          contain the vector which defines the elementary reflector
          H(i), IA <= i <= IA+K-1, as returned by PZTZRZF in the
          K rows of its distributed matrix argument A(IA:IA+K-1,JA:*).
          A(IA:IA+K-1,JA:*) is modified by the routine but restored on
          exit.
  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 LOCc(IA+K-1).
          This array contains the scalar factors TAU(i) of the
          elementary reflectors H(i) as returned by PZTZRZF.
          TAU is tied to the distributed matrix A.
  C       (local input/local output) COMPLEX*16 pointer into the
          local memory to an array of dimension (LLD_C,LOCc(JC+N-1)).
          On entry, the local pieces of the distributed matrix sub(C).
          On exit, sub( C ) is overwritten by Q*sub( C ) or Q'*sub( C )
          or sub( C )*Q' or sub( C )*Q.
  IC      (global input) INTEGER
          The row index in the global array C indicating the first
          row of sub( C ).
  JC      (global input) INTEGER
          The column index in the global array C indicating the
          first column of sub( C ).
  DESCC   (global and local input) INTEGER array of dimension DLEN_.
          The array descriptor for the distributed matrix C.
  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
          if SIDE = 'L',
            LWORK >= MAX( (MB_A*(MB_A-1))/2, ( MpC0 + MAX( MqA0 +
                     NUMROC( NUMROC( M+IROFFC, MB_A, 0, 0, NPROW ),
                             MB_A, 0, 0, LCMP ), NqC0 ) )*MB_A ) +
                     MB_A * MB_A
          else if SIDE = 'R',
            LWORK >= MAX( (MB_A*(MB_A-1))/2, (MpC0 + NqC0)*MB_A ) +
                     MB_A * MB_A
          end if
          where LCMP = LCM / NPROW with LCM = ICLM( NPROW, NPCOL ),
          IROFFA = MOD( IA-1, MB_A ), ICOFFA = MOD( JA-1, NB_A ),
          IACOL = INDXG2P( JA, NB_A, MYCOL, CSRC_A, NPCOL ),
          MqA0 = NUMROC( M+ICOFFA, NB_A, MYCOL, IACOL, NPCOL ),
          IROFFC = MOD( IC-1, MB_C ), ICOFFC = MOD( JC-1, NB_C ),
          ICROW = INDXG2P( IC, MB_C, MYROW, RSRC_C, NPROW ),
          ICCOL = INDXG2P( JC, NB_C, MYCOL, CSRC_C, NPCOL ),
          MpC0 = NUMROC( M+IROFFC, MB_C, MYROW, ICROW, NPROW ),
          NqC0 = NUMROC( N+ICOFFC, NB_C, MYCOL, ICCOL, NPCOL ),
          ILCM, 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.
  Alignment requirements
  ======================
  The distributed submatrices A(IA:*, JA:*) and C(IC:IC+M-1,JC:JC+N-1)
  must verify some alignment properties, namely the following
  expressions should be true:
  If SIDE = 'L',
    ( NB_A.EQ.MB_C .AND. ICOFFA.EQ.IROFFC )
  If SIDE = 'R',
    ( NB_A.EQ.NB_C .AND. ICOFFA.EQ.ICOFFC .AND. IACOL.EQ.ICCOL )
  =====================================================================
     .. Parameters ..
 
Display dynamic version Find AutoScroll Reload FontSize: - + Hide Comments Hide Blanks Frame FullScreen MailPrint

  
001        SUBROUTINE PZUNMRZ( SIDE , TRANS , M , N , K , L , A , IA , JA , DESCA ,
002       $TAU , C , IC , JC , DESCC , WORK , LWORK , 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        CHARACTER SIDE , TRANS
011        INTEGER IA , IC , INFO , JA , JC , K , L , LWORK , M , N
012        INTEGER BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ ,
013       $LLD_ , MB_ , M_ , NB_ , N_ , RSRC_
014        PARAMETER( BLOCK_CYCLIC_2D = 1 , DLEN_ = 9 , DTYPE_ = 1 ,
015       $CTXT_ = 2 , M_ = 3 , N_ = 4 , MB_ = 5 , NB_ = 6 ,
016       $RSRC_ = 7 , CSRC_ = 8 , LLD_ = 9 )
017  *     ..
018  *     .. Local Scalars ..
019        LOGICAL LEFT , LQUERY , NOTRAN
020        CHARACTER COLBTOP , ROWBTOP , TRANST
021        INTEGER I , I1 , I2 , I3 , IACOL , IB , ICC , ICCOL , ICOFFA ,
022       $ICOFFC , ICROW , ICTXT , IINFO , IPW , IROFFC , JAA ,
023       $JCC , LCM , LCMP , LWMIN , MI , MPC0 , MQA0 , MYCOL ,
024       $MYROW , NI , NPCOL , NPROW , NQ , NQC0
025  *     ..
026  *     .. Local Arrays ..
027        INTEGER IDUM1( 5 ) , IDUM2( 5 )
028  *     ..
029  *     .. External Subroutines ..
030        EXTERNAL BLACS_GRIDINFO , CHK1MAT , PCHK2MAT , PB_TOPGET ,
031       $PB_TOPSET , PXERBLA , PZLARZB , PZLARZT ,
032       $PZUNMR3  
033  *     ..
034  *     .. External Functions ..
035        LOGICAL LSAME
036        INTEGER ICEIL , ILCM , INDXG2P , NUMROC
037        EXTERNAL ICEIL , ILCM , INDXG2P , LSAME , NUMROC
038  *     ..
039  *     .. Intrinsic Functions ..
040        INTRINSIC DBLE , DCMPLX , ICHAR , MAX , MIN , MOD
041  *     ..
042  *     .. Executable Statements ..
043  
044  *     Get grid parameters
045  
046        ICTXT = DESCA( CTXT_ )
047        CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
048  
049  *     Test the input parameters
050  
051        INFO = 0
052        IF( NPROW.EQ. - 1 ) THEN
053            INFO = - (900 + CTXT_)
054        ELSE
055            LEFT = LSAME( SIDE , 'L' )
056            NOTRAN = LSAME( TRANS , 'N' )
057  
058  *         NQ is the order of Q
059  
060            IF( LEFT ) THEN
061                NQ = M
062                CALL CHK1MAT( K , 5 , M , 3 , IA , JA , DESCA , 10 , INFO )
063            ELSE
064                NQ = N
065                CALL CHK1MAT( K , 5 , N , 4 , IA , JA , DESCA , 10 , INFO )
066            END IF
067            CALL CHK1MAT( M , 3 , N , 4 , IC , JC , DESCC , 15 , INFO )
068            IF( INFO.EQ.0 ) THEN
069                ICOFFA = MOD( JA - 1 , DESCA( NB_ ) )
070                IROFFC = MOD( IC - 1 , DESCC( MB_ ) )
071                ICOFFC = MOD( JC - 1 , DESCC( NB_ ) )
072                IACOL = INDXG2P( JA , DESCA( NB_ ) , MYCOL , DESCA( CSRC_ ) ,
073       $        NPCOL )
074                ICROW = INDXG2P( IC , DESCC( MB_ ) , MYROW , DESCC( RSRC_ ) ,
075       $        NPROW )
076                ICCOL = INDXG2P( JC , DESCC( NB_ ) , MYCOL , DESCC( CSRC_ ) ,
077       $        NPCOL )
078                MPC0 = NUMROC( M + IROFFC , DESCC( MB_ ) , MYROW , ICROW , NPROW )
079                NQC0 = NUMROC( N + ICOFFC , DESCC( NB_ ) , MYCOL , ICCOL , NPCOL )
080  
081                IF( LEFT ) THEN
082                    MQA0 = NUMROC( M + ICOFFA , DESCA( NB_ ) , MYCOL , IACOL ,
083       $            NPCOL )
084                    LCM = ILCM( NPROW , NPCOL )
085                    LCMP = LCM / NPROW
086                    LWMIN = MAX(( DESCA( MB_ ) * ( DESCA( MB_ ) - 1 ) )
087       $            / 2 ,( MPC0 + MAX( MQA0 + NUMROC( NUMROC(
088       $            M + IROFFC , DESCA( MB_ ) , 0 , 0 , NPROW ) ,
089       $            DESCA( MB_ ) , 0 , 0 , LCMP ) , NQC0 ) ) *
090       $            DESCA( MB_ ) ) + DESCA( MB_ ) * DESCA( MB_ )
091                ELSE
092                    LWMIN = MAX(( DESCA( MB_ ) * ( DESCA( MB_ ) - 1 ) ) / 2 ,
093       $( MPC0 + NQC0 ) * DESCA( MB_ ) ) +
094       $            DESCA( MB_ ) * DESCA( MB_ )
095                END IF
096  
097                WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )
098                LQUERY =( LWORK.EQ. - 1 )
099                IF( .NOT.LEFT .AND. .NOT.LSAME( SIDE , 'R' ) ) THEN
100                    INFO = - 1
101                ELSE IF( .NOT.NOTRAN .AND. .NOT.LSAME( TRANS , 'C' ) ) THEN
102                    INFO = - 2
103                ELSE IF( K.LT.0 .OR. K.GT.NQ ) THEN
104                    INFO = - 5
105                ELSE IF( K.LT.0 .OR. K.GT.NQ ) THEN
106                    INFO = - 6
107                ELSE IF( LEFT .AND. DESCA( NB_ ).NE.DESCC( MB_ ) ) THEN
108                    INFO = - (1000 + NB_)
109                ELSE IF( LEFT .AND. ICOFFA.NE.IROFFC ) THEN
110                    INFO = - 13
111                ELSE IF( .NOT.LEFT .AND. ICOFFA.NE.ICOFFC ) THEN
112                    INFO = - 14
113                ELSE IF( .NOT.LEFT .AND. IACOL.NE.ICCOL ) THEN
114                    INFO = - 14
115                ELSE IF( .NOT.LEFT .AND. DESCA( NB_ ).NE.DESCC( NB_ ) ) THEN
116                    INFO = - (1500 + NB_)
117                ELSE IF( ICTXT.NE.DESCC( CTXT_ ) ) THEN
118                    INFO = - (1500 + CTXT_)
119                ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
120                    INFO = - 17
121                END IF
122            END IF
123            IF( LEFT ) THEN
124                IDUM1( 1 ) = ICHAR( 'L' )
125            ELSE
126                IDUM1( 1 ) = ICHAR( 'R' )
127            END IF
128            IDUM2( 1 ) = 1
129            IF( NOTRAN ) THEN
130                IDUM1( 2 ) = ICHAR( 'N' )
131            ELSE
132                IDUM1( 2 ) = ICHAR( 'C' )
133            END IF
134            IDUM2( 2 ) = 2
135            IDUM1( 3 ) = K
136            IDUM2( 3 ) = 5
137            IDUM1( 4 ) = L
138            IDUM2( 4 ) = 6
139            IF( LWORK.EQ. - 1 ) THEN
140                IDUM1( 5 ) = - 1
141            ELSE
142                IDUM1( 5 ) = 1
143            END IF
144            IDUM2( 5 ) = 17
145            IF( LEFT ) THEN
146                CALL PCHK2MAT( K , 5 , M , 3 , IA , JA , DESCA , 10 , M , 3 , N , 4 ,
147       $        IC , JC , DESCC , 15 , 5 , IDUM1 , IDUM2 , INFO )
148            ELSE
149                CALL PCHK2MAT( K , 5 , N , 4 , IA , JA , DESCA , 10 , M , 3 , N , 4 ,
150       $        IC , JC , DESCC , 15 , 5 , IDUM1 , IDUM2 , INFO )
151            END IF
152        END IF
153  
154        IF( INFO.NE.0 ) THEN
155            CALL PXERBLA( ICTXT , 'PZUNMRZ' , - INFO )
156            RETURN
157        ELSE IF( LQUERY ) THEN
158            RETURN
159        END IF
160  
161  *     Quick return if possible
162  
163        IF( M.EQ.0 .OR. N.EQ.0 .OR. K.EQ.0 )
164       $    RETURN
165  
166            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
167            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
168  
169            IF(( LEFT .AND. .NOT.NOTRAN ) .OR.
170       $( .NOT.LEFT .AND. NOTRAN ) ) THEN
171            I1 = MIN( ICEIL( IA , DESCA( MB_ ) ) * DESCA( MB_ ) , IA + K - 1 )
172       $    + 1
173            I2 = IA + K - 1
174            I3 = DESCA( MB_ )
175        ELSE
176            I1 = MAX(((IA + K - 2) / DESCA( MB_ ) ) * DESCA( MB_ ) + 1 , IA )
177            I2 = MIN( ICEIL( IA , DESCA( MB_ ) ) * DESCA( MB_ ) , IA + K - 1 )
178       $    + 1
179            I3 = - DESCA( MB_ )
180        END IF
181  
182        IF( LEFT ) THEN
183            NI = N
184            JCC = JC
185            JAA = JA + M - L
186        ELSE
187            MI = M
188            ICC = IC
189            JAA = JA + N - L
190            CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , ' ' )
191            IF( NOTRAN ) THEN
192                CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , 'I - ring' )
193            ELSE
194                CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , 'D - ring' )
195            END IF
196        END IF
197  
198        IF( NOTRAN ) THEN
199            TRANST = 'C'
200        ELSE
201            TRANST = 'N'
202        END IF
203  
204        IF(( LEFT .AND. .NOT.NOTRAN ) .OR.
205       $( .NOT.LEFT .AND. NOTRAN ) ) THEN
206        IB = I1 - IA
207        IF( LEFT ) THEN
208            MI = M
209        ELSE
210            NI = N
211        END IF
212        CALL PZUNMR3 ( SIDE , TRANS , MI , NI , IB , L , A , IA , JA , DESCA ,
213       $TAU , C , IC , JC , DESCC , WORK , LWORK , IINFO )
214        END IF
215  
216        IPW = DESCA( MB_ )*DESCA( MB_ ) + 1
217        DO 10 I = I1 , I2 , I3
218            IB = MIN( DESCA( MB_ ) , K - I + IA )
219  
220  *         Form the triangular factor of the block reflector
221  *         H = H(i + ib - 1) . . . H(i + 1) H(i)
222  
223            CALL PZLARZT ( 'Backward' , 'Rowwise' , L , IB , A , I , JAA , DESCA ,
224       $    TAU , WORK , WORK( IPW ) )
225            IF( LEFT ) THEN
226  
227  *             H or H' is applied to C(ic + i - ia : ic + m - 1 , jc : jc + n - 1)
228  
229                MI = M - I + IA
230                ICC = IC + I - IA
231            ELSE
232  
233  *             H or H' is applied to C(ic : ic + m - 1 , jc + i - ia : jc + n - 1)
234  
235                NI = N - I + IA
236                JCC = JC + I - IA
237            END IF
238  
239  *         Apply H or H'
240  
241            CALL PZLARZB ( SIDE , TRANST , 'Backward' , 'Rowwise' , MI , NI , IB ,
242       $    L , A , I , JAA , DESCA , WORK , C , ICC , JCC , DESCC ,
243       $    WORK( IPW ) )
244     10 CONTINUE
245  
246        IF(( LEFT .AND. .NOT.NOTRAN ) .OR.
247       $( .NOT.LEFT .AND. NOTRAN ) ) THEN
248        IB = I2 - IA
249        IF( LEFT ) THEN
250            MI = M
251        ELSE
252            NI = N
253        END IF
254        CALL PZUNMR3 ( SIDE , TRANS , MI , NI , IB , L , A , IA , JA , DESCA ,
255       $TAU , C , IC , JC , DESCC , WORK , LWORK , IINFO )
256        END IF
257  
258        CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
259        CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
260  
261        WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )
262  
263        RETURN
264  
265  *     End of PZUNMRZ
266  
267        END