Routine PDORGQR() Documented By Universal Report

Routine: PDORGQR()

# lines:	336
# code:	336
# comment:	0
# blank:	0
# Variables:	45
# Callers:	0
# Callings:	4
# Words:	143
# Keywords:	80

..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PDORGQR generates an M-by-N real distributed matrix Q denoting
  A(IA:IA+M-1,JA:JA+N-1) with orthonormal columns, which is defined as
  the first N columns of a product of K elementary reflectors of order
  M
        Q  =  H(1) H(2) . . . H(k)
  as returned by PDGEQRF.
  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. M >= N >= 0.
  K       (global input) INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q. N >= K >= 0.
  A       (local input/local output) DOUBLE PRECISION pointer into the
          local memory to an array of dimension (LLD_A,LOCc(JA+N-1)).
          On entry, the j-th column must contain the vector which
          defines the elementary reflector H(j), JA <= j <= JA+K-1, as
          returned by PDGEQRF in the K columns of its distributed
          matrix argument A(IA:*,JA:JA+K-1). 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) DOUBLE PRECISION array, dimension LOCc(JA+K-1)
          This array contains the scalar factors TAU(j) of the
          elementary reflectors H(j) as returned by PDGEQRF.
          TAU is tied to the distributed matrix A.
  WORK    (local workspace/local output) DOUBLE PRECISION 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 >= NB_A * ( NqA0 + MpA0 + NB_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 PDORGQR( 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        DOUBLE PRECISION ZERO
017        PARAMETER( ZERO = 0.0D + 0 )
018  *     ..
019  *     .. Local Scalars ..
020        LOGICAL LQUERY
021        CHARACTER COLBTOP , ROWBTOP
022        INTEGER I , IACOL , IAROW , ICTXT , IINFO , IPW , J , JB , JL ,
023       $JN , LWMIN , MPA0 , MYCOL , MYROW , NPCOL , NPROW ,
024       $NQA0
025  *     ..
026  *     .. Local Arrays ..
027        INTEGER IDUM1( 2 ) , IDUM2( 2 )
028  *     ..
029  *     .. External Subroutines ..
030        EXTERNAL BLACS_GRIDINFO , CHK1MAT , PCHK1MAT , PDLARFB ,
031       $PDLARFT , PDLASET , PDORG2R , PB_TOPGET ,
032       $PB_TOPSET , PXERBLA
033  *     ..
034  *     .. External Functions ..
035        INTEGER ICEIL , INDXG2P , NUMROC
036        EXTERNAL ICEIL , INDXG2P , NUMROC
037  *     ..
038  *     .. Intrinsic Functions ..
039        INTRINSIC DBLE , MAX , MIN , MOD
040  *     ..
041  *     .. Executable Statements ..
042  
043  *     Get grid parameters
044  
045        ICTXT = DESCA( CTXT_ )
046        CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
047  
048  *     Test the input parameters
049  
050        INFO = 0
051        IF( NPROW.EQ. - 1 ) THEN
051               
052            INFO = - (700 + CTXT_)
053        ELSE
053               
054            CALL CHK1MAT( M , 1 , N , 2 , IA , JA , DESCA , 7 , INFO )
055            IF( INFO.EQ.0 ) THEN
055                   
056                IAROW = INDXG2P( IA , DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) ,
057       $        NPROW )
058                IACOL = INDXG2P( JA , DESCA( NB_ ) , MYCOL , DESCA( CSRC_ ) ,
059       $        NPCOL )
060                MPA0 = NUMROC( M + MOD( IA - 1 , DESCA( MB_ ) ) , DESCA( MB_ ) ,
061       $        MYROW , IAROW , NPROW )
062                NQA0 = NUMROC( N + MOD( JA - 1 , DESCA( NB_ ) ) , DESCA( NB_ ) ,
063       $        MYCOL , IACOL , NPCOL )
064                LWMIN = DESCA( NB_ ) * ( MPA0 + NQA0 + DESCA( NB_ ) )
065  
066                WORK( 1 ) = DBLE( LWMIN )
067                LQUERY =( LWORK.EQ. - 1 )
068                IF( N.GT.M ) THEN
068                       
069                    INFO = - 2
070                ELSE IF( K.LT.0 .OR. K.GT.N ) THEN
070                       
071                    INFO = - 3
072                ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
072                       
073                    INFO = - 10
074                END IF
075            END IF
076            IDUM1( 1 ) = K
077            IDUM2( 1 ) = 3
078            IF( LWORK.EQ. - 1 ) THEN
078                   
079                IDUM1( 2 ) = - 1
080            ELSE
080                   
081                IDUM1( 2 ) = 1
082            END IF
083            IDUM2( 2 ) = 10
084            CALL PCHK1MAT( M , 1 , N , 2 , IA , JA , DESCA , 7 , 2 , IDUM1 , IDUM2 ,
085       $    INFO )
086        END IF
087  
088        IF( INFO.NE.0 ) THEN
088               
089            CALL PXERBLA( ICTXT , 'PDORGQR' , - INFO )
090            RETURN
091        ELSE IF( LQUERY ) THEN
091               
092            RETURN
093        END IF
094  
095  *     Quick return if possible
096  
097        IF( N.LE.0 )
097               
098       $    RETURN
099  
100            IPW = DESCA( NB_ )*DESCA( NB_ ) + 1
101            JN = MIN( ICEIL( JA , DESCA( NB_ ) ) * DESCA( NB_ ) , JA + K - 1 )
102            JL = MAX(((JA + K - 2) / DESCA( NB_ ) ) * DESCA( NB_ ) + 1 , JA )
103            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
104            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
105            CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , 'D - ring' )
106            CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , ' ' )
107  
108            CALL PDLASET ( 'All' , JL - JA , JA + N - JL , ZERO , ZERO , A , IA , JL ,
109       $    DESCA )
110  
111  *         Use unblocked code for the last or only block.
112  
113            CALL PDORG2R ( M - JL + JA , JA + N - JL , JA + K - JL , A , IA + JL - JA , JL , DESCA ,
114       $    TAU , WORK , LWORK , IINFO )
115  
116  *         Is there at least one block of columns to loop over ?
117  
118            IF( JL.GT.JN + 1 ) THEN
119  
120  *             Use blocked code
121  
121                   
122                DO 10 J = JL - DESCA( NB_ ) , JN + 1 , - DESCA( NB_ )
122                       
123                    JB = MIN( DESCA( NB_ ) , JA + N - J )
124                    I = IA + J - JA
125  
126                    IF( J + JB.LE.JA + N - 1 ) THEN
127  
128  *                     Form the triangular factor of the block reflector
129  *                     H = H(j) H(j + 1) . . . H(j + jb - 1)
130  
130                           
131                        CALL PDLARFT ( 'Forward' , 'Columnwise' , M - I + IA , JB , A , I ,
132       $                J , DESCA , TAU , WORK , WORK( IPW ) )
133  
134  *                     Apply H to A(i : ia + m - 1 , j + jb : ja + n - 1) from the left
135  
136                        CALL PDLARFB ( 'Left' , 'No transpose' , 'Forward' ,
137       $                'Columnwise' , M - I + IA , N - J - JB + JA , JB , A , I ,
138       $                J , DESCA , WORK , A , I , J + JB , DESCA ,
139       $                WORK( IPW ) )
140                    END IF
141  
142  *                 Apply H to rows i : ia + m - 1 of current block
143  
144                    CALL PDORG2R ( M - I + IA , JB , JB , A , I , J , DESCA , TAU , WORK ,
145       $            LWORK , IINFO )
146  
147  *                 Set rows ia : i - 1 of current block to zero
148  
149                    CALL PDLASET ( 'All' , I - IA , JB , ZERO , ZERO , A , IA , J , DESCA )
150  
151     10         CONTINUE
152  
152               
153            END IF
154  
155  *         Handle first block separately
156  
157            IF( JL.GT.JA ) THEN
158  
158                   
159                JB = JN - JA + 1
160  
161  *             Form the triangular factor of the block reflector
162  *             H = H(j) H(j + 1) . . . H(j + jb - 1)
163  
164                CALL PDLARFT ( 'Forward' , 'Columnwise' , M , JB , A , IA , JA , DESCA ,
165       $        TAU , WORK , WORK( IPW ) )
166  
167  *             Apply H to A(ia : ia + m - 1 , ja + jb : ja + n - 1) from the left
168  
169                CALL PDLARFB ( 'Left' , 'No transpose' , 'Forward' , 'Columnwise' ,
170       $        M , N - JB , JB , A , IA , JA , DESCA , WORK , A , IA ,
171       $        JA + JB , DESCA , WORK( IPW ) )
172  
173  *             Apply H to rows ia : ia + m - 1 of current block
174  
175                CALL PDORG2R ( M , JB , JB , A , IA , JA , DESCA , TAU , WORK , LWORK ,
176       $        IINFO )
177  
178            END IF
179  
180            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
181            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
182  
183            WORK( 1 ) = DBLE( LWMIN )
184  
185            RETURN
186  
187  *         End of PDORGQR
188  
189        END3444

Variables in Routine PDORGQR()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	2	2
DOUBLE PRECISION	1	4
INTEGER	40	172
LOGICAL	1	1
REAL	1	4
TOTAL	45	183

List of Variables

CHARACTER

COLBTOP ROWBTOP

DOUBLE PRECISION

ZERO

INTEGER

BLOCK_CYCLIC_2D CSRC_ CTXT_ DLEN_ DTYPE_
I IA IACOL IAROW ICEIL
ICTXT IDUM1( 2 ) IDUM2( 2 ) IINFO INDXG2P
INFO IPW J JA JB
JL JN 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 <--- JI = IA + J - JA, JAI = IA + J - JA, IAI = IA + J - JA

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

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

ICTXT <--- CTXT_ICTXT = DESCA( CTXT_ )

IDUM1 <--- KIDUM1( 1 ) = K

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

IPW <--- NB_IPW = DESCA( NB_ )*DESCA( NB_ ) + 1

J <--- JL, JN, NB_

JB <--- JJB = MIN( DESCA( NB_ ), JA+N-J ), JAJB = MIN( DESCA( NB_ ), JA+N-J ){2JB = JN - JA + 1}, JNJB = JN - JA + 1, NJB = MIN( DESCA( NB_ ), JA+N-J ), NB_JB = MIN( DESCA( NB_ ), JA+N-J )

JL <--- JA, K, NB_

JN <--- ICEIL, JA, K, NB_

LWMIN <--- MPA0, NB_, NQA0

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

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

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