Routine PSORMQL() Documented By Universal Report

Routine: PSORMQL()

File: SRC\psormql.f

# lines:	458
# code:	458
# comment:	0
# blank:	0
# Variables:	62
# Callers:	1
# Callings:	3
# Words:	255
# Keywords:	173

..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PSORMQL overwrites the general real 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 = 'T':      Q**T * sub( C )       sub( C ) * Q**T
  where Q is a real orthogonal distributed matrix defined as the
  product of K elementary reflectors
        Q = H(k) . . . H(2) H(1)
  as returned by PSGEQLF. 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**T from the Left;
          = 'R': apply Q or Q**T from the Right.
  TRANS   (global input) CHARACTER
          = 'N':  No transpose, apply Q;
          = 'T':  Transpose, apply Q**T.
  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.
  A       (local input) REAL pointer into the local memory
          to an array of dimension (LLD_A,LOCc(JA+K-1)). On entry, the
          j-th column must contain the vector which defines the elemen-
          tary reflector H(j), JA <= j <= JA+K-1, as returned by
          PSGEQLF in the K columns of its distributed matrix
          argument A(IA:*,JA:JA+K-1). A(IA:*,JA:JA+K-1) is modified by
          the routine but restored on exit.
          If SIDE = 'L', LLD_A >= MAX( 1, LOCr(IA+M-1) ),
          if SIDE = 'R', LLD_A >= MAX( 1, LOCr(IA+N-1) ).
  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) REAL, array, dimension LOCc(JA+N-1)
          This array contains the scalar factors TAU(j) of the
          elementary reflectors H(j) as returned by PSGEQLF.
          TAU is tied to the distributed matrix A.
  C       (local input/local output) REAL 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) REAL 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( (NB_A*(NB_A-1))/2, (NqC0 + MpC0)*NB_A ) +
                     NB_A * NB_A
          else if SIDE = 'R',
            LWORK >= MAX( (NB_A*(NB_A-1))/2, ( NqC0 + MAX( NpA0 +
                     NUMROC( NUMROC( N+ICOFFC, NB_A, 0, 0, NPCOL ),
                             NB_A, 0, 0, LCMQ ), MpC0 ) )*NB_A ) +
                     NB_A * NB_A
          end if
          where LCMQ = LCM / NPCOL with LCM = ICLM( NPROW, NPCOL ),
          IROFFA = MOD( IA-1, MB_A ), ICOFFA = MOD( JA-1, NB_A ),
          IAROW = INDXG2P( IA, MB_A, MYROW, RSRC_A, NPROW ),
          NpA0 = NUMROC( N+IROFFA, MB_A, MYROW, IAROW, NPROW ),
          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',
    ( MB_A.EQ.MB_C .AND. IROFFA.EQ.IROFFC .AND. IAROW.EQ.ICROW )
  If SIDE = 'R',
    ( MB_A.EQ.NB_C .AND. IROFFA.EQ.ICOFFC )
  =====================================================================
     .. Parameters ..

Display dynamic version

FontSize: - +

001        SUBROUTINE PSORMQL( SIDE , TRANS , M , N , K , A , IA , JA , DESCA , TAU ,
002       $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 , 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
021        INTEGER IAROW , ICCOL , ICOFFC , ICROW , ICTXT , IINFO , IPW ,
022       $IROFFA , IROFFC , J , J1 , J2 , J3 , JB , LCM , LCMQ ,
023       $LWMIN , MI , MPC0 , MYCOL , MYROW , NI , NPA0 , NPCOL ,
024       $NPROW , NQ , NQC0
025  *     ..
026  *     .. Local Arrays ..
027        INTEGER IDUM1( 4 ) , IDUM2( 4 )
028  *     ..
029  *     .. External Subroutines ..
030        EXTERNAL BLACS_GRIDINFO , CHK1MAT , PCHK2MAT , PSLARFB ,
031       $PSLARFT , PSORM2L , PB_TOPGET , PB_TOPSET , PXERBLA
032  *     ..
033  *     .. External Functions ..
034        LOGICAL LSAME
035        INTEGER ICEIL , ILCM , INDXG2P , NUMROC
036        EXTERNAL ICEIL , ILCM , INDXG2P , LSAME , NUMROC
037  *     ..
038  *     .. Intrinsic Functions ..
039        INTRINSIC ICHAR , MAX , MIN , MOD , REAL
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 = - (900 + CTXT_)
053        ELSE
053               
054            LEFT = LSAME( SIDE , 'L' )
055            NOTRAN = LSAME( TRANS , 'N' )
056  
057  *         NQ is the order of Q
058  
059            IF( LEFT ) THEN
059                   
060                NQ = M
061                CALL CHK1MAT( M , 3 , K , 5 , IA , JA , DESCA , 9 , INFO )
062            ELSE
062                   
063                NQ = N
064                CALL CHK1MAT( N , 4 , K , 5 , IA , JA , DESCA , 9 , INFO )
065            END IF
066            CALL CHK1MAT( M , 3 , N , 4 , IC , JC , DESCC , 14 , INFO )
067            IF( INFO.EQ.0 ) THEN
067                   
068                IROFFA = MOD( IA - 1 , DESCA( MB_ ) )
069                IROFFC = MOD( IC - 1 , DESCC( MB_ ) )
070                ICOFFC = MOD( JC - 1 , DESCC( NB_ ) )
071                IAROW = INDXG2P( IA , DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) ,
072       $        NPROW )
073                ICROW = INDXG2P( IC , DESCC( MB_ ) , MYROW , DESCC( RSRC_ ) ,
074       $        NPROW )
075                ICCOL = INDXG2P( JC , DESCC( NB_ ) , MYCOL , DESCC( CSRC_ ) ,
076       $        NPCOL )
077                MPC0 = NUMROC( M + IROFFC , DESCC( MB_ ) , MYROW , ICROW , NPROW )
078                NQC0 = NUMROC( N + ICOFFC , DESCC( NB_ ) , MYCOL , ICCOL , NPCOL )
079  
080                IF( LEFT ) THEN
080                       
081                    LWMIN = MAX(( DESCA( NB_ ) * ( DESCA( NB_ ) - 1 ) ) / 2 ,
082       $( MPC0 + NQC0 ) * DESCA( NB_ ) ) +
082                       
083       $            DESCA( NB_ ) * DESCA( NB_ )
084                ELSE
084                       
085                    NPA0 = NUMROC( N + IROFFA , DESCA( MB_ ) , MYROW , IAROW ,
086       $            NPROW )
087                    LCM = ILCM( NPROW , NPCOL )
088                    LCMQ = LCM / NPCOL
089                    LWMIN = MAX(( DESCA( NB_ ) * ( DESCA( NB_ ) - 1 ) )
090       $            / 2 ,( NQC0 + MAX( NPA0 + NUMROC( NUMROC(
091       $            N + ICOFFC , DESCA( NB_ ) , 0 , 0 , NPCOL ) ,
092       $            DESCA( NB_ ) , 0 , 0 , LCMQ ) , MPC0 ) ) *
093       $            DESCA( NB_ ) ) + DESCA( NB_ ) * DESCA( NB_ )
094                END IF
095  
096                WORK( 1 ) = REAL( LWMIN )
097                LQUERY =( LWORK.EQ. - 1 )
098                IF( .NOT.LEFT .AND. .NOT.LSAME( SIDE , 'R' ) ) THEN
098                       
099                    INFO = - 1
100                ELSE IF( .NOT.NOTRAN .AND. .NOT.LSAME( TRANS , 'T' ) ) THEN
100                       
101                    INFO = - 2
102                ELSE IF( K.LT.0 .OR. K.GT.NQ ) THEN
102                       
103                    INFO = - 5
104                ELSE IF( .NOT.LEFT .AND. DESCA( MB_ ).NE.DESCC( NB_ ) ) THEN
104                       
105                    INFO = - (900 + NB_)
106                ELSE IF( LEFT .AND. IROFFA.NE.IROFFC ) THEN
106                       
107                    INFO = - 12
108                ELSE IF( LEFT .AND. IAROW.NE.ICROW ) THEN
108                       
109                    INFO = - 12
110                ELSE IF( .NOT.LEFT .AND. IROFFA.NE.ICOFFC ) THEN
110                       
111                    INFO = - 13
112                ELSE IF( LEFT .AND. DESCA( MB_ ).NE.DESCC( MB_ ) ) THEN
112                       
113                    INFO = - (1400 + MB_)
114                ELSE IF( ICTXT.NE.DESCC( CTXT_ ) ) THEN
114                       
115                    INFO = - (1400 + CTXT_)
116                ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
116                       
117                    INFO = - 16
118                END IF
119            END IF
120  
121            IF( LEFT ) THEN
121                   
122                IDUM1( 1 ) = ICHAR( 'L' )
123            ELSE
123                   
124                IDUM1( 1 ) = ICHAR( 'R' )
125            END IF
126            IDUM2( 1 ) = 1
127            IF( NOTRAN ) THEN
127                   
128                IDUM1( 2 ) = ICHAR( 'N' )
129            ELSE
129                   
130                IDUM1( 2 ) = ICHAR( 'T' )
131            END IF
132            IDUM2( 2 ) = 2
133            IDUM1( 3 ) = K
134            IDUM2( 3 ) = 5
135            IF( LWORK.EQ. - 1 ) THEN
135                   
136                IDUM1( 4 ) = - 1
137            ELSE
137                   
138                IDUM1( 4 ) = 1
139            END IF
140            IDUM2( 4 ) = 16
141            IF( LEFT ) THEN
141                   
142                CALL PCHK2MAT( M , 3 , K , 5 , IA , JA , DESCA , 9 , M , 3 , N , 4 , IC ,
143       $        JC , DESCC , 14 , 4 , IDUM1 , IDUM2 , INFO )
144            ELSE
144                   
145                CALL PCHK2MAT( N , 4 , K , 5 , IA , JA , DESCA , 9 , M , 3 , N , 4 , IC ,
146       $        JC , DESCC , 14 , 4 , IDUM1 , IDUM2 , INFO )
147            END IF
148        END IF
149  
150        IF( INFO.NE.0 ) THEN
150               
151            CALL PXERBLA( ICTXT , 'PSORMQL' , - INFO )
152            RETURN
153        ELSE IF( LQUERY ) THEN
153               
154            RETURN
155        END IF
156  
157  *     Quick return if possible
158  
159        IF( M.EQ.0 .OR. N.EQ.0 .OR. K.EQ.0 )
159               
160       $    RETURN
161  
162            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
163            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
164  
165            IF(( LEFT .AND. NOTRAN ) .OR.
166       $( .NOT.LEFT .AND. .NOT.NOTRAN ) ) THEN
166               
167            J1 = MIN( ICEIL( JA , DESCA( NB_ ) )*DESCA( NB_ ) , JA + K - 1 ) + 1
168            J2 = JA + K - 1
169            J3 = DESCA( NB_ )
170        ELSE
170               
171            J1 = MAX(((JA + K - 2) / DESCA( NB_ ) ) * DESCA( NB_ ) + 1 , JA )
172            J2 = MIN( ICEIL( JA , DESCA( NB_ ) )*DESCA( NB_ ) , JA + K - 1 ) + 1
173            J3 = - DESCA( NB_ )
174        END IF
175  
176        IF( LEFT ) THEN
176               
177            NI = N
178            IF( NOTRAN ) THEN
178                   
179                CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , 'I - ring' )
180            ELSE
180                   
181                CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , 'D - ring' )
182            END IF
183            CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , ' ' )
184        ELSE
184               
185            MI = M
186        END IF
187  
188  *     Use unblocked code for the first block if necessary
189  
190        IF(( LEFT .AND. NOTRAN ) .OR.
191       $( .NOT.LEFT .AND. .NOT.NOTRAN ) ) THEN
192        JB = J1 - JA
193        IF( LEFT ) THEN
193               
194            MI = M - K + JB
195        ELSE
195               
196            NI = N - K + JB
197        END IF
198        CALL PSORM2L ( SIDE , TRANS , MI , NI , JB , A , IA , JA , DESCA , TAU ,
199       $C , IC , JC , DESCC , WORK , LWORK , IINFO )
200        END IF
201  
202        IPW = DESCA( NB_ ) * DESCA( NB_ ) + 1
203        DO 10 J = J1 , J2 , J3
203               
204            JB = MIN( DESCA( NB_ ) , K - J + JA )
205  
206  *         Form the triangular factor of the block reflector
207  *         H = H(j + jb - 1) . . . H(j + 1) H(j)
208  
209            CALL PSLARFT ( 'Backward' , 'Columnwise' , NQ - K + J + JB - JA , JB ,
210       $    A , IA , J , DESCA , TAU , WORK , WORK( IPW ) )
211            IF( LEFT ) THEN
212  
213  *             H or H' is applied to C(ic : ic + m - k + j + jb - ja - 1 , jc : jc + n - 1)
214  
214                   
215                MI = M - K + J + JB - JA
216            ELSE
217  
218  *             H or H' is applied to C(ic : ic + m - 1 , jc : jc + n - k + j + jb - ja - 1)
219  
219                   
220                NI = N - K + J + JB - JA
221            END IF
222  
223  *         Apply H or H'
224  
225            CALL PSLARFB ( SIDE , TRANS , 'Backward' , 'Columnwise' , MI , NI ,
226       $    JB , A , IA , J , DESCA , WORK , C , IC , JC , DESCC ,
227       $    WORK( IPW ) )
228     10 CONTINUE
229  
230        IF(( LEFT .AND. .NOT.NOTRAN ) .OR.
231       $( .NOT.LEFT .AND. NOTRAN ) ) THEN
232        JB = J2 - JA
233        IF( LEFT ) THEN
233               
234            MI = M - K + JB
235        ELSE
235               
236            NI = N - K + JB
237        END IF
238        CALL PSORM2L ( SIDE , TRANS , MI , NI , JB , A , IA , JA , DESCA , TAU ,
239       $C , IC , JC , DESCC , WORK , LWORK , IINFO )
240        END IF
241  
242        CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
243        CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
244  
245        WORK( 1 ) = REAL( LWMIN )
246  
247        RETURN
248  
249  *     End of PSORMQL
250  
251        END2834

Variables in Routine PSORMQL()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	4	4
INTEGER	53	240
LOGICAL	4	4
REAL	1	4
TOTAL	62	252

List of Variables

CHARACTER

COLBTOP ROWBTOP SIDE TRANS

INTEGER

BLOCK_CYCLIC_2D CSRC_ CTXT_ DLEN_ DTYPE_
IA IAROW IC ICCOL ICEIL
ICOFFC ICROW ICTXT IDUM1( 4 ) IDUM2( 4 )
IINFO ILCM INDXG2P INFO IPW
IROFFA IROFFC J J1 J2
J3 JA JB JC K
LCM LCMQ LLD_ LWMIN LWORK
M M_ MB_ MI MPC0
MYCOL MYROW N N_ NB_
NI NPA0 NPCOL NPROW NQ
NQC0 NUMROC RSRC_

LOGICAL

LEFT LQUERY LSAME NOTRAN

REAL

WORK

Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence
-
- -
IAROW <--- INDXG2P, MB_, MYROW, NPROW, RSRC_, IA

ICCOL <--- INDXG2P, CSRC_, JC, MYCOL, NB_, NPCOL

ICOFFC <--- JCICOFFC = MOD( JC-1, DESCC( NB_ ) ), NB_ICOFFC = MOD( JC-1, DESCC( NB_ ) )

ICROW <--- INDXG2P, MB_, MYROW, NPROW, RSRC_, IC

ICTXT <--- CTXT_ICTXT = DESCA( CTXT_ )

IDUM1 <--- KIDUM1( 3 ) = K, NIDUM1( 2 ) = ICHAR( 'N' )

INFO <--- CTXT_INFO = -(1400+CTXT_){2INFO = -(900+CTXT_)}, MB_INFO = -(1400+MB_), NB_INFO = -(900+NB_)

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

IROFFA <--- MB_IROFFA = MOD( IA-1, DESCA( MB_ ) ), IAIROFFA = MOD( IA-1, DESCA( MB_ ) )

IROFFC <--- MB_IROFFC = MOD( IC-1, DESCC( MB_ ) ), ICIROFFC = MOD( IC-1, DESCC( MB_ ) )

J <--- J1DO 10 J = J1, J2, J3, J2DO 10 J = J1, J2, J3, J3DO 10 J = J1, J2, J3

J1 <--- ICEIL, JA{2}, K{2}, NB_{2}

J2 <--- ICEIL, JAJ2 = JA+K-1{2}, KJ2 = JA+K-1{2}, NB_

J3 <--- NB_J3 = DESCA( NB_ ){2J3 = -DESCA( NB_ )}

JB <--- JJB = MIN( DESCA( NB_ ), K-J+JA ), J1JB = J1 - JA, J2JB = J2 - JA, JAJB = J1 - JA{2JB = MIN( DESCA( NB_ ), K-J+JA ), 3JB = J2 - JA}, KJB = MIN( DESCA( NB_ ), K-J+JA ), NB_JB = MIN( DESCA( NB_ ), K-J+JA )

LCM <--- ILCMLCM = ILCM( NPROW, NPCOL ), NPCOLLCM = ILCM( NPROW, NPCOL ), NPROWLCM = ILCM( NPROW, NPCOL )

LCMQ <--- LCMLCMQ = LCM / NPCOL, NPCOLLCMQ = LCM / NPCOL

LEFT <--- LSAMELEFT = LSAME( SIDE, 'L' ), SIDELEFT = LSAME( SIDE, 'L' )

LWMIN <--- ICOFFC, LCMQ, MPC0{2}, N, NB_{2}, NPA0, NPCOL, NQC0{2}, NUMROC

MI <--- JMI = M - K + J + JB - JA, JAMI = M - K + J + JB - JA, JBMI = M - K + JB{2MI = M - K + J + JB - JA, 3MI = M - K + JB}, KMI = M - K + JB{2MI = M - K + J + JB - JA, 3MI = M - K + JB}, MMI = M{2MI = M - K + JB, 3MI = M - K + J + JB - JA, 4MI = M - K + JB}

MPC0 <--- ICROW, IROFFC, M, MB_, MYROW, NPROW, NUMROC

NI <--- JNI = N - K + J + JB - JA, JANI = N - K + J + JB - JA, JBNI = N - K + JB{2NI = N - K + J + JB - JA, 3NI = N - K + JB}, KNI = N - K + JB{2NI = N - K + J + JB - JA, 3NI = N - K + JB}, NNI = N{2NI = N - K + JB, 3NI = N - K + J + JB - JA, 4NI = N - K + JB}

NOTRAN <--- LSAMENOTRAN = LSAME( TRANS, 'N' ), NNOTRAN = LSAME( TRANS, 'N' ), TRANSNOTRAN = LSAME( TRANS, 'N' )

NPA0 <--- IROFFA, MB_, MYROW, N, NPROW, NUMROC, IAROW

NQ <--- MNQ = M, NNQ = N

NQC0 <--- ICCOL, ICOFFC, MYCOL, N, NB_, NPCOL, NUMROC

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

Analysis elements of the routine PSORMQL()
Put the mouse over each element to display detailed matching information

Assigned variables
		BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ , IAROW , ICCOL , ICOFFC , ICROW , ICTXT , IDUM1 , IDUM2 , INFO , IPW , IROFFA , IROFFC , J , J1 , J2 , J3 , JB , LCM , LCMQ , LEFT , LLD_ , LQUERY , LWMIN , M_ , MB_ , MI , MPC0 , N_ , NB_ , NI , NOTRAN , NPA0 , NQ , NQC0 , RSRC_ , WORK

Active variables
		A , BLOCK_CYCLIC_2D , C , COLBTOP , CSRC_ , CTXT_ , DESCA , DESCC , DLEN_ , DTYPE_ , IA , IAROW , IC , ICCOL , ICEIL , ICOFFC , ICROW , ICTXT , IDUM1 , IDUM2 , IINFO , ILCM , INDXG2P , INFO , IPW , IROFFA , IROFFC , J , J1 , J2 , J3 , JA , JB , JC , K , LCM , LCMQ , LEFT , LLD_ , LQUERY , LSAME , LWMIN , LWORK , M , M_ , MB_ , MI , MPC0 , MYCOL , MYROW , N , N_ , NB_ , NI , NOTRAN , NPA0 , NPCOL , NPROW , NQ , NQC0 , NUMROC , ROWBTOP , RSRC_ , SIDE , TAU , TRANS , WORK

Accessed arrays [ array name : associated index ]
	C	: ic:ic+m-1,jc:jc+n-k+j+jb-ja-1 , ic:ic+m-k+j+jb-ja-1,jc:jc+n-1
	DESCA	: CTXT_ , MB_ , MB_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , RSRC_
	DESCC	: CSRC_ , CTXT_ , MB_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_ , RSRC_
	ICEIL	: JA, DESCA( NB_ ) , JA, DESCA( NB_ )
	IDUM1	: 1 , 1 , 2 , 2 , 3 , 4 , 4 , 4
	IDUM2	: 1 , 2 , 3 , 4 , 4
	ILCM	: NPROW, NPCOL
	LSAME	: SIDE, 'L' , SIDE, 'R' , TRANS, 'N' , TRANS, 'T'
	NUMROC	: M+IROFFC, DESCC( MB_ ), MYROW, ICROW, NPROW , N+ICOFFC, DESCC( NB_ ), MYCOL, ICCOL, NPCOL
	WORK	: 1 , 1 , IPW , IPW

Conditional statements [ statement : associated predicate ]
	do	: `(` 10 J = J1 , J2 , J3 `)`
	for	: `(` the first block if necessary `)`
	if	: `(` NPROW.EQ. - 1 `)` , `(` LEFT `)` , `(` INFO.EQ.0 `)` , `(` LEFT `)` , `(` (.NOT.LEFT .AND. .NOT.LSAME( SIDE , 'R' ) ) `)` , `(` (.NOT.NOTRAN .AND. .NOT.LSAME( TRANS , 'T' ) ) `)` , `(` K.LT.0 .OR. K.GT.NQ `)` , `(` (.NOT.LEFT .AND. DESCA( MB_ ).NE.DESCC( NB_ ) ) `)` , `(` LEFT .AND. IROFFA.NE.IROFFC `)` , `(` LEFT .AND. IAROW.NE.ICROW `)` , `(` .NOT.LEFT .AND. IROFFA.NE.ICOFFC `)` , `(` (LEFT .AND. DESCA( MB_ ).NE.DESCC( MB_ ) ) `)` , `(` (ICTXT.NE.DESCC( CTXT_ ) ) `)` , `(` LWORK.LT.LWMIN .AND. .NOT.LQUERY `)` , `(` LEFT `)` , `(` NOTRAN `)` , `(` LWORK.EQ. - 1 `)` , `(` LEFT `)` , `(` INFO.NE.0 `)` , `(` LQUERY `)` , `(` possible `)` , `(` M.EQ.0 .OR. N.EQ.0 .OR. K.EQ.0 `)` , `(` (( LEFT .AND. NOTRAN ) .OR. `)` , `(` LEFT `)` , `(` NOTRAN `)` , `(` necessary `)` , `(` (( LEFT .AND. NOTRAN ) .OR. `)` , `(` LEFT `)` , `(` LEFT `)` , `(` (( LEFT .AND. .NOT.NOTRAN ) .OR. `)` , `(` LEFT `)`