Routine: PCGETRI()  File: SRC\pcgetri.f

 
 
# lines: 374
  # code: 374
  # comment: 0
  # blank:0
# Variables:50
# Callers:0
# Callings:4
# Words:151
# Keywords:89
 

 

 
..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PCGETRI computes the inverse of a distributed matrix using the LU
  factorization computed by PCGETRF. This method inverts U and then
  computes the inverse of sub( A ) = A(IA:IA+N-1,JA:JA+N-1) denoted
  InvA by solving the system InvA*L = inv(U) for InvA.
  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
  =========
  N       (global input) INTEGER
          The number of rows and columns to be operated on, i.e. the
          order of the distributed submatrix sub( A ). N >= 0.
  A       (local input/local output) COMPLEX pointer into the
          local memory to an array of dimension (LLD_A,LOCc(JA+N-1)).
          On entry, the local pieces of the L and U obtained by the
          factorization sub( A ) = P*L*U computed by PCGETRF. On
          exit, if INFO = 0, sub( A ) contains the inverse of the
          original distributed matrix sub( A ).
  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.
  IPIV    (local input) INTEGER array, dimension LOCr(M_A)+MB_A
          keeps track of the pivoting information. IPIV(i) is the
          global row index the local row i was swapped with.  This
          array is tied to the distributed matrix A.
  WORK    (local workspace/local output) COMPLEX 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 = LOCr(N+MOD(IA-1,MB_A))*NB_A. WORK is used to keep a
          copy of at most an entire column block of sub( A ).
          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.
  IWORK   (local workspace/local output) INTEGER array,
                                                    dimension (LIWORK)
          On exit, IWORK(1) returns the minimal and optimal LIWORK.
  LIWORK  (local or global input) INTEGER
          The dimension of the array IWORK used as workspace for
          physically transposing the pivots.
          LIWORK is local input and must be at least
          if NPROW == NPCOL then
            LIWORK = LOCc( N_A + MOD(JA-1, NB_A) ) + NB_A,
          else
            LIWORK =  LOCc( N_A + MOD(JA-1, NB_A) ) +
                      MAX( CEIL(CEIL(LOCr(M_A)/MB_A)/(LCM/NPROW)),
                           NB_A )
              where LCM is the least common multiple of process
              rows and columns (NPROW and NPCOL).
          end if
          If LIWORK = -1, then LIWORK 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.
            > 0:  If INFO = K, U(IA+K-1,IA+K-1) is exactly zero; the
                  matrix is singular and its inverse could not be
                  computed.
  =====================================================================
     .. Parameters ..
 
Display dynamic version Find AutoScroll Reload FontSize: - + Hide Comments Hide Blanks Frame FullScreen MailPrint

  
001        SUBROUTINE PCGETRI( N , A , IA , JA , DESCA , IPIV , WORK , LWORK ,
002       $IWORK , LIWORK , INFO )
003  
004  *     -- ScaLAPACK routine(version 1.7.4) --
005  *     University of Tennessee , Knoxville , Oak Ridge National Laboratory ,
006  *     and University of California , Berkeley.
007  *     v1.7.4 : May 10 , 2006
008  *     v1.7 : May 1 , 1997
009  
010  *     .. Scalar Arguments ..
011        INTEGER IA , INFO , JA , LIWORK , LWORK , 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        COMPLEX ZERO , ONE
018        PARAMETER( ZERO = 0.0E + 0 , ONE = 1.0E + 0 )
019  *     ..
020  *     .. Local Scalars ..
021        LOGICAL LQUERY
022        INTEGER I , IACOL , IAROW , ICOFF , ICTXT , IROFF , IW , J ,
023       $JB , JN , LCM , LIWMIN , LWMIN , MP , MYCOL , MYROW ,
024       $NN , NP , NPCOL , NPROW , NQ
025  *     ..
026  *     .. Local Arrays ..
027        INTEGER DESCW( DLEN_ ) , IDUM1( 2 ) , IDUM2( 2 )
028  *     ..
029  *     .. External Subroutines ..
030        EXTERNAL BLACS_GRIDINFO , CHK1MAT , DESCSET , PCHK1MAT ,
031       $PCGEMM , PCLACPY , PCLASET , PCLAPIV ,
032       $PCTRSM , PCTRTRI , PXERBLA
033  *     ..
034  *     .. External Functions ..
035        INTEGER ICEIL , ILCM , INDXG2P , NUMROC
036        EXTERNAL ICEIL , ILCM , INDXG2P , NUMROC
037  *     ..
038  *     .. Intrinsic Functions ..
039        INTRINSIC 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
052            INFO = - (500 + CTXT_)
053        ELSE
054            CALL CHK1MAT( N , 1 , N , 1 , IA , JA , DESCA , 5 , INFO )
055            IF( INFO.EQ.0 ) THEN
056                IROFF = MOD( IA - 1 , DESCA( MB_ ) )
057                ICOFF = MOD( JA - 1 , DESCA( NB_ ) )
058                IAROW = INDXG2P( IA , DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) ,
059       $        NPROW )
060                NP = NUMROC( N + IROFF , DESCA( MB_ ) , MYROW , IAROW , NPROW )
061                LWMIN = NP * DESCA( NB_ )
062  
063                MP = NUMROC( DESCA( M_ ) , DESCA( MB_ ) , MYROW ,
064       $        DESCA( RSRC_ ) , NPROW )
065                NQ = NUMROC( DESCA( N_ ) , DESCA( NB_ ) , MYCOL ,
066       $        DESCA( CSRC_ ) , NPCOL )
067                IF( NPROW.EQ.NPCOL ) THEN
068                    LIWMIN = NQ + DESCA( NB_ )
069                ELSE
070  
071  *                 Use the formula for the workspace given in PxLAPIV
072  *                 to compute the minimum size LIWORK for IWORK
073  
074  *                 The formula in PxLAPIV is
075  *                 LDW = LOCc( M_P + MOD(IP - 1 , MB_P) ) +
076  *                 MB_P * CEIL( CEIL(LOCr(M_P) / MB_P) / (LCM / NPROW) )
077  
078  *                 where
079  *                 M_P is the global length of the pivot vector
080  *                 MP = DESCA( M_ ) + DESCA( MB_ ) * NPROW
081  *                 I_P is IA
082  *                 I_P = IA
083  *                 MB_P is the block size use for the block cyclic distribution of the
084  *                 pivot vector
085  *                 MB_P = DESCA(MB_ )
086  *                 LOCc( . )
087  *                 NUMROC( . , DESCA( NB_ ) , MYCOL , DESCA( CSRC_ ) , NPCOL )
088  *                 LOCr( . )
089  *                 NUMROC( . , DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) , NPROW )
090  *                 CEIL( X / Y )
091  *                 ICEIL( X , Y )
092  *                 LCM
093  *                 LCM = ILCM( NPROW , NPCOL )
094  
095                    LCM = ILCM( NPROW , NPCOL )
096                    LIWMIN = NUMROC( DESCA( M_ ) + DESCA( MB_ ) * NPROW
097       $            + MOD( IA - 1 , DESCA( MB_ ) ) , DESCA( NB_ ) ,
098       $            MYCOL , DESCA( CSRC_ ) , NPCOL ) +
099       $            MAX( DESCA( MB_ ) * ICEIL( ICEIL(
100       $            NUMROC( DESCA( M_ ) + DESCA( MB_ ) * NPROW ,
101       $            DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) , NPROW ) ,
102       $            DESCA( MB_ ) ) , LCM / NPROW ) , DESCA( NB_ ) )
103  
104                END IF
105  
106                WORK( 1 ) = REAL( LWMIN )
107                IWORK( 1 ) = LIWMIN
108                LQUERY =( LWORK.EQ. - 1 .OR. LIWORK.EQ. - 1 )
109                IF( IROFF.NE.ICOFF .OR. IROFF.NE.0 ) THEN
110                    INFO = - 4
111                ELSE IF( DESCA( MB_ ).NE.DESCA( NB_ ) ) THEN
112                    INFO = - (500 + NB_)
113                ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
114                    INFO = - 8
115                ELSE IF( LIWORK.LT.LIWMIN .AND. .NOT.LQUERY ) THEN
116                    INFO = - 10
117                END IF
118            END IF
119            IF( LWORK.EQ. - 1 ) THEN
120                IDUM1( 1 ) = - 1
121            ELSE
122                IDUM1( 1 ) = 1
123            END IF
124            IDUM2( 1 ) = 8
125            IF( LIWORK.EQ. - 1 ) THEN
126                IDUM1( 2 ) = - 1
127            ELSE
128                IDUM1( 2 ) = 1
129            END IF
130            IDUM2( 2 ) = 10
131            CALL PCHK1MAT( N , 1 , N , 1 , IA , JA , DESCA , 5 , 2 , IDUM1 , IDUM2 ,
132       $    INFO )
133        END IF
134  
135        IF( INFO.NE.0 ) THEN
136            CALL PXERBLA( ICTXT , 'PCGETRI' , - INFO )
137            RETURN
138        ELSE IF( LQUERY ) THEN
139            RETURN
140        END IF
141  
142  *     Quick return if possible
143  
144        IF( N.EQ.0 )
145       $    RETURN
146  
147  *         Form inv(U). If INFO > 0 from PCTRTRI , then U is singular ,
148  *         and the inverse is not computed.
149  
150            CALL PCTRTRI ( 'Upper' , 'Non - unit' , N , A , IA , JA , DESCA , INFO )
151            IF( INFO.GT.0 )
152       $        RETURN
153  
154  *             Define array descriptor for working array WORK
155  
156                JN = MIN( ICEIL( JA , DESCA( NB_ ) ) * DESCA( NB_ ) , JA + N - 1 )
157                NN =(( JA + N - 2 ) / DESCA( NB_ ) ) * DESCA( NB_ ) + 1
158                IACOL = INDXG2P( NN , DESCA( NB_ ) , MYCOL , DESCA( CSRC_ ) , NPCOL )
159                CALL DESCSET( DESCW , N + IROFF , DESCA( NB_ ) , DESCA( MB_ ) ,
160       $        DESCA( NB_ ) , IAROW , IACOL , ICTXT , MAX( 1 , NP ) )
161                IW = IROFF + 1
162  
163  *             Solve the equation inv(A)*L = inv(U) for inv(A) using blocked code.
164  
165                DO 10 J = NN , JN + 1 , - DESCA( NB_ )
166                    JB = MIN( DESCA( NB_ ) , JA + N - J )
167                    I = IA + J - JA
168  
169  *                 Copy current block column of L to WORK and replace with zeros.
170  
171                    CALL PCLACPY ( 'Lower' , JA + N - 1 - J , JB , A , I + 1 , J , DESCA ,
172       $            WORK , IW + J - JA + 1 , 1 , DESCW )
173                    CALL PCLASET ( 'Lower' , JA + N - 1 - J , JB , ZERO , ZERO , A , I + 1 , J ,
174       $            DESCA )
175  
176  *                 Compute current block column of inv(A).
177  
178                    IF( J + JB.LE.JA + N - 1 )
179       $                CALL PCGEMM( 'No transpose' , 'No transpose' , N , JB ,
180       $                JA + N - J - JB , - ONE , A , IA , J + JB , DESCA , WORK ,
181       $                IW + J + JB - JA , 1 , DESCW , ONE , A , IA , J , DESCA )
182                        CALL PCTRSM( 'Right' , 'Lower' , 'No transpose' , 'Unit' , N , JB ,
183       $                ONE , WORK , IW + J - JA , 1 , DESCW , A , IA , J , DESCA )
184                        DESCW( CSRC_ ) = MOD( DESCW( CSRC_ ) + NPCOL - 1 , NPCOL )
185  
186     10         CONTINUE
187  
188  *             Handle the last block of columns separately
189  
190                JB = JN - JA + 1
191  
192  *             Copy current block column of L to WORK and replace with zeros.
193  
194                CALL PCLACPY ( 'Lower' , N - 1 , JB , A , IA + 1 , JA , DESCA , WORK , IW + 1 ,
195       $        1 , DESCW )
196                CALL PCLASET ( 'Lower' , N - 1 , JB , ZERO , ZERO , A , IA + 1 , JA , DESCA )
197  
198  *             Compute current block column of inv(A).
199  
200                IF( JA + JB.LE.JA + N - 1 )
201       $            CALL PCGEMM( 'No transpose' , 'No transpose' , N , JB ,
202       $            N - JB , - ONE , A , IA , JA + JB , DESCA , WORK , IW + JB , 1 ,
203       $            DESCW , ONE , A , IA , JA , DESCA )
204                    CALL PCTRSM( 'Right' , 'Lower' , 'No transpose' , 'Unit' , N , JB ,
205       $            ONE , WORK , IW , 1 , DESCW , A , IA , JA , DESCA )
206  
207  *                 Use the row pivots and apply them to the columns of the global
208  *                 matrix.
209  
210                    CALL DESCSET( DESCW , DESCA( M_ ) + DESCA( MB_ )*NPROW , 1 ,
211       $            DESCA( MB_ ) , 1 , DESCA( RSRC_ ) , MYCOL , ICTXT ,
212       $            MP + DESCA( MB_ ) )
213                    CALL PCLAPIV ( 'Backward' , 'Columns' , 'Column' , N , N , A , IA ,
214       $            JA , DESCA , IPIV , IA , 1 , DESCW , IWORK )
215  
216                    WORK( 1 ) = REAL( LWMIN )
217                    IWORK( 1 ) = LIWMIN
218  
219                    RETURN
220  
221  *                 End of PCGETRI
222  
223                END