|
|
| |
| # lines: |
872 | | # code: |
872 | | # comment: | 0 | |
# blank: | 0 |
| # Variables: | 116 |
| # Callers: | 2 |
| # Callings: | 4 |
| # Words: | 633 |
| # Keywords: | 402 |
|
|
|
|
|
..
.. Array Arguments ..
..
Purpose
=======
PSSTEBZ computes the eigenvalues of a symmetric tridiagonal matrix in
parallel. The user may ask for all eigenvalues, all eigenvalues in
the interval [VL, VU], or the eigenvalues indexed IL through IU. A
static partitioning of work is done at the beginning of PSSTEBZ which
results in all processes finding an (almost) equal number of
eigenvalues.
NOTE : It is assumed that the user is on an IEEE machine. If the user
is not on an IEEE mchine, set the compile time flag NO_IEEE
to 1 (in SLmake.inc). The features of IEEE arithmetic that
are needed for the "fast" Sturm Count are : (a) infinity
arithmetic (b) the sign bit of a double precision floating
point number is assumed be in the 32nd or 64th bit position
(c) the sign of negative zero.
See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal
Matrix", Report CS41, Computer Science Dept., Stanford
University, July 21, 1966.
Arguments
=========
ICTXT (global input) INTEGER
The BLACS context handle.
RANGE (global input) CHARACTER
Specifies which eigenvalues are to be found.
= 'A': ("All") all eigenvalues will be found.
= 'V': ("Value") all eigenvalues in the interval
[VL, VU] will be found.
= 'I': ("Index") the IL-th through IU-th eigenvalues (of the
entire matrix) will be found.
ORDER (global input) CHARACTER
Specifies the order in which the eigenvalues and their block
numbers are stored in W and IBLOCK.
= 'B': ("By Block") the eigenvalues will be grouped by
split-off block (see IBLOCK, ISPLIT) and
ordered from smallest to largest within
the block.
= 'E': ("Entire matrix")
the eigenvalues for the entire matrix
will be ordered from smallest to largest.
N (global input) INTEGER
The order of the tridiagonal matrix T. N >= 0.
VL (global input) REAL
If RANGE='V', the lower bound of the interval to be searched
for eigenvalues. Eigenvalues less than VL will not be
returned. Not referenced if RANGE='A' or 'I'.
VU (global input) REAL
If RANGE='V', the upper bound of the interval to be searched
for eigenvalues. Eigenvalues greater than VU will not be
returned. VU must be greater than VL. Not referenced if
RANGE='A' or 'I'.
IL (global input) INTEGER
If RANGE='I', the index (from smallest to largest) of the
smallest eigenvalue to be returned. IL must be at least 1.
Not referenced if RANGE='A' or 'V'.
IU (global input) INTEGER
If RANGE='I', the index (from smallest to largest) of the
largest eigenvalue to be returned. IU must be at least IL
and no greater than N. Not referenced if RANGE='A' or 'V'.
ABSTOL (global input) REAL
The absolute tolerance for the eigenvalues. An eigenvalue
(or cluster) is considered to be located if it has been
determined to lie in an interval whose width is ABSTOL or
less. If ABSTOL is less than or equal to zero, then ULP*|T|
will be used, where |T| means the 1-norm of T.
Eigenvalues will be computed most accurately when ABSTOL is
set to the underflow threshold SLAMCH('U'), not zero.
Note : If eigenvectors are desired later by inverse iteration
( PSSTEIN ), ABSTOL should be set to 2*PSLAMCH('S').
D (global input) REAL array, dimension (N)
The n diagonal elements of the tridiagonal matrix T. To
avoid overflow, the matrix must be scaled so that its largest
entry is no greater than overflow**(1/2) * underflow**(1/4)
in absolute value, and for greatest accuracy, it should not
be much smaller than that.
E (global input) REAL array, dimension (N-1)
The (n-1) off-diagonal elements of the tridiagonal matrix T.
To avoid overflow, the matrix must be scaled so that its
largest entry is no greater than overflow**(1/2) *
underflow**(1/4) in absolute value, and for greatest
accuracy, it should not be much smaller than that.
M (global output) INTEGER
The actual number of eigenvalues found. 0 <= M <= N.
(See also the description of INFO=2)
NSPLIT (global output) INTEGER
The number of diagonal blocks in the matrix T.
1 <= NSPLIT <= N.
W (global output) REAL array, dimension (N)
On exit, the first M elements of W contain the eigenvalues
on all processes.
IBLOCK (global output) INTEGER array, dimension (N)
At each row/column j where E(j) is zero or small, the
matrix T is considered to split into a block diagonal
matrix. On exit IBLOCK(i) specifies which block (from 1
to the number of blocks) the eigenvalue W(i) belongs to.
NOTE: in the (theoretically impossible) event that bisection
does not converge for some or all eigenvalues, INFO is set
to 1 and the ones for which it did not are identified by a
negative block number.
ISPLIT (global output) INTEGER array, dimension (N)
The splitting points, at which T breaks up into submatrices.
The first submatrix consists of rows/columns 1 to ISPLIT(1),
the second of rows/columns ISPLIT(1)+1 through ISPLIT(2),
etc., and the NSPLIT-th consists of rows/columns
ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.
(Only the first NSPLIT elements will actually be used, but
since the user cannot know a priori what value NSPLIT will
have, N words must be reserved for ISPLIT.)
WORK (local workspace) REAL array, dimension ( MAX( 5*N, 7 ) )
LWORK (local input) INTEGER
size of array WORK must be >= MAX( 5*N, 7 )
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) INTEGER array, dimension ( MAX( 4*N, 14 ) )
LIWORK (local input) INTEGER
size of array IWORK must be >= MAX( 4*N, 14, NPROCS )
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 INFO = -i, the i-th argument had an illegal value
> 0 : some or all of the eigenvalues failed to converge or
were not computed:
= 1 : Bisection failed to converge for some eigenvalues;
these eigenvalues are flagged by a negative block
number. The effect is that the eigenvalues may not
be as accurate as the absolute and relative
tolerances. This is generally caused by arithmetic
which is less accurate than PSLAMCH says.
= 2 : There is a mismatch between the number of
eigenvalues output and the number desired.
= 3 : RANGE='i', and the Gershgorin interval initially
used was incorrect. No eigenvalues were computed.
Probable cause: your machine has sloppy floating
point arithmetic.
Cure: Increase the PARAMETER "FUDGE", recompile,
and try again.
Internal Parameters
===================
RELFAC REAL, default = 2.0
The relative tolerance. An interval [a,b] lies within
"relative tolerance" if b-a < RELFAC*ulp*max(|a|,|b|),
where "ulp" is the machine precision (distance from 1 to
the next larger floating point number.)
FUDGE REAL, default = 2.0
A "fudge factor" to widen the Gershgorin intervals. Ideally,
a value of 1 should work, but on machines with sloppy
arithmetic, this needs to be larger. The default for
publicly released versions should be large enough to handle
the worst machine around. Note that this has no effect
on the accuracy of the solution.
=====================================================================
.. Intrinsic Functions ..
|
|
|
|
001 SUBROUTINE PSSTEBZ( ICTXT , RANGE , ORDER , N , VL , VU , IL , IU ,
002 $ABSTOL , D , E , M , NSPLIT , W , IBLOCK , ISPLIT ,
003 $WORK , LWORK , IWORK , LIWORK , INFO )
004
005 * -- ScaLAPACK routine(version 1.7) --
006 * University of Tennessee , Knoxville , Oak Ridge National Laboratory ,
007 * and University of California , Berkeley.
008 * November 15 , 1997
009
010 * .. Scalar Arguments ..
011 CHARACTER ORDER , RANGE
012 INTEGER ICTXT , IL , INFO , IU , LIWORK , LWORK , M , N ,
013 $NSPLIT
014 REAL ABSTOL , VL , VU
015 INTRINSIC ABS , ICHAR , MAX , MIN , MOD , REAL
016 * ..
017 * .. External Functions ..
018 LOGICAL LSAME
019 INTEGER BLACS_PNUM
020 REAL PSLAMCH
021 EXTERNAL LSAME , BLACS_PNUM , PSLAMCH
022 * ..
023 * .. External Subroutines ..
024 EXTERNAL BLACS_FREEBUFF , BLACS_GET , BLACS_GRIDEXIT ,
025 $BLACS_GRIDINFO , BLACS_GRIDMAP , GLOBCHK ,
026 $IGEBR2D , IGEBS2D , IGERV2D , IGESD2D , IGSUM2D ,
027 $PSLAEBZ , PSLAIECT , PSLAPDCT , PSLASNBT , PXERBLA ,
028 $SGEBR2D , SGEBS2D , SGERV2D , SGESD2D , SLASRT2
029 * ..
030 * .. Parameters ..
031 INTEGER BLOCK_CYCLIC_2D , DLEN_ , DTYPE_ , CTXT_ , M_ , N_ ,
032 $MB_ , NB_ , RSRC_ , CSRC_ , LLD_
033 PARAMETER( BLOCK_CYCLIC_2D = 1 , DLEN_ = 9 , DTYPE_ = 1 ,
034 $CTXT_ = 2 , M_ = 3 , N_ = 4 , MB_ = 5 , NB_ = 6 ,
035 $RSRC_ = 7 , CSRC_ = 8 , LLD_ = 9 )
036 INTEGER BIGNUM , DESCMULT
037 PARAMETER( BIGNUM = 10000 , DESCMULT = 100 )
038 REAL ZERO , ONE , TWO , FIVE , HALF
039 PARAMETER( ZERO = 0.0E + 0 , ONE = 1.0E + 0 , TWO = 2.0E + 0 ,
040 $FIVE = 5.0E + 0 , HALF = 1.0E + 0 / TWO )
041 REAL FUDGE , RELFAC
042 PARAMETER( FUDGE = 2.0E + 0 , RELFAC = 2.0E + 0 )
043 * ..
044 * .. Local Scalars ..
045 LOGICAL LQUERY
046 INTEGER BLKNO , FOUND , I , IBEGIN , IEFLAG , IEND , IFRST ,
047 $IINFO , ILAST , ILOAD , IM , IMYLOAD , IN , INDRIW1 ,
048 $INDRIW2 , INDRW1 , INDRW2 , INXTLOAD , IOFF ,
049 $IORDER , IOUT , IRANGE , IRECV , IREM , ITMP1 ,
050 $ITMP2 , J , JB , K , LAST , LEXTRA , LREQ , MYCOL ,
051 $MYROW , NALPHA , NBETA , NCMP , NEIGINT , NEXT , NGL ,
052 $NGLOB , NGU , NINT , NPCOL , NPROW , OFFSET ,
053 $ONEDCONTEXT , P , PREV , REXTRA , RREQ , SELF ,
054 $TORECV
055 REAL ALPHA , ATOLI , BETA , BNORM , DRECV , DSEND , GL ,
056 $GU , INITVL , INITVU , LSAVE , MID , PIVMIN , RELTOL ,
057 $SAFEMN , TMP1 , TMP2 , TNORM , ULP
058 * ..
059 * .. Local Arrays ..
060 INTEGER IDUM( 5 , 2 )
061 * ..
062 * .. Executable Statements ..
063 * This is just to keep ftnchek happy
064 IF( BLOCK_CYCLIC_2D*CSRC_*CTXT_*DLEN_*DTYPE_*LLD_*MB_*M_*NB_*N_*
064  
065 $ RSRC_.LT.0 )RETURN
066
067 * Set up process grid
068
069 CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
070
071 INFO = 0
072 M = 0
073
074 * Decode RANGE
075
076 IF( LSAME( RANGE , 'A' ) ) THEN
076
077 IRANGE = 1
078 ELSE IF( LSAME( RANGE , 'V' ) ) THEN
078
079 IRANGE = 2
080 ELSE IF( LSAME( RANGE , 'I' ) ) THEN
080
081 IRANGE = 3
082 ELSE
082
083 IRANGE = 0
084 END IF
085
086 * Decode ORDER
087
088 IF( LSAME( ORDER , 'B' ) ) THEN
088
089 IORDER = 2
090 ELSE IF( LSAME( ORDER , 'E' ) .OR. LSAME( ORDER , 'A' ) ) THEN
090
091 IORDER = 1
092 ELSE
092
093 IORDER = 0
094 END IF
095
096 * Check for Errors
097
098 IF( NPROW.EQ. - 1 ) THEN
098
099 INFO = - 1
100 ELSE
101
102 * Get machine constants
103
103
104 SAFEMN = PSLAMCH( ICTXT , 'S' )
105 ULP = PSLAMCH( ICTXT , 'P' )
106 RELTOL = ULP*RELFAC
107 IDUM( 1 , 1 ) = ICHAR( RANGE )
108 IDUM( 1 , 2 ) = 2
109 IDUM( 2 , 1 ) = ICHAR( ORDER )
110 IDUM( 2 , 2 ) = 3
111 IDUM( 3 , 1 ) = N
112 IDUM( 3 , 2 ) = 4
113 NGLOB = 5
114 IF( IRANGE.EQ.3 ) THEN
114
115 IDUM( 4 , 1 ) = IL
116 IDUM( 4 , 2 ) = 7
117 IDUM( 5 , 1 ) = IU
118 IDUM( 5 , 2 ) = 8
119 ELSE
119
120 IDUM( 4 , 1 ) = 0
121 IDUM( 4 , 2 ) = 0
122 IDUM( 5 , 1 ) = 0
123 IDUM( 5 , 2 ) = 0
124 END IF
125 IF( MYROW.EQ.0 .AND. MYCOL.EQ.0 ) THEN
125
126 WORK( 1 ) = ABSTOL
127 IF( IRANGE.EQ.2 ) THEN
127
128 WORK( 2 ) = VL
129 WORK( 3 ) = VU
130 ELSE
130
131 WORK( 2 ) = ZERO
132 WORK( 3 ) = ZERO
133 END IF
134 CALL SGEBS2D( ICTXT , 'ALL' , ' ' , 3 , 1 , WORK , 3 )
135 ELSE
135
136 CALL SGEBR2D( ICTXT , 'ALL' , ' ' , 3 , 1 , WORK , 3 , 0 , 0 )
137 END IF
138 LQUERY =( LWORK.EQ. - 1 .OR. LIWORK.EQ. - 1 )
139 IF( INFO.EQ.0 ) THEN
139
140 IF( IRANGE.EQ.0 ) THEN
140
141 INFO = - 2
142 ELSE IF( IORDER.EQ.0 ) THEN
142
143 INFO = - 3
144 ELSE IF( IRANGE.EQ.2 .AND. VL.GE.VU ) THEN
144
145 INFO = - 5
146 ELSE IF( IRANGE.EQ.3 .AND.( IL.LT.1 .OR. IL.GT.MAX( 1 ,
146
147 $ N ) ) ) THEN
148 INFO = - 6
149 ELSE IF( IRANGE.EQ.3 .AND.( IU.LT.MIN( N ,
149
150 $ IL ) .OR. IU.GT.N ) ) THEN
151 INFO = - 7
152 ELSE IF( LWORK.LT.MAX( 5*N , 7 ) .AND. .NOT.LQUERY ) THEN
152
153 INFO = - 18
154 ELSE IF( LIWORK.LT.MAX( 4*N , 14 , NPROW*NPCOL ) .AND. .NOT.
154
155 $ LQUERY ) THEN
156 INFO = - 20
157 ELSE IF( IRANGE.EQ.2 .AND.( ABS( WORK( 2 ) - VL ).GT.FIVE*
157
158 $ ULP*ABS( VL ) ) ) THEN
159 INFO = - 5
160 ELSE IF( IRANGE.EQ.2 .AND.( ABS( WORK( 3 ) - VU ).GT.FIVE*
160
161 $ ULP*ABS( VU ) ) ) THEN
162 INFO = - 6
163 ELSE IF( ABS( WORK( 1 ) - ABSTOL ).GT.FIVE*ULP*ABS( ABSTOL ) )
163
164 $ THEN
165 INFO = - 9
166 END IF
167 END IF
168 IF( INFO.EQ.0 )
168
169 $ INFO = BIGNUM
170 CALL GLOBCHK( ICTXT , NGLOB , IDUM , 5 , IWORK , INFO )
171 IF( INFO.EQ.BIGNUM ) THEN
171
172 INFO = 0
173 ELSE IF( MOD( INFO , DESCMULT ).EQ.0 ) THEN
173
174 INFO = - INFO / DESCMULT
175 ELSE
175
176 INFO = - INFO
177 END IF
178 END IF
179 WORK( 1 ) = REAL( MAX( 5*N , 7 ) )
180 IWORK( 1 ) = MAX( 4*N , 14 , NPROW*NPCOL )
181
182 IF( INFO.NE.0 ) THEN
182
183 CALL PXERBLA( ICTXT , 'PSSTEBZ' , - INFO )
184 RETURN
185 ELSE IF( LWORK.EQ. - 1 .AND. LIWORK.EQ. - 1 ) THEN
185
186 RETURN
187 END IF
188
189 * Quick return if possible
190
191 IF( N.EQ.0 )
191
192 $ RETURN
193
194 K = 1
195 DO 20 I = 0 , NPROW - 1
195
196 DO 10 J = 0 , NPCOL - 1
196
197 IWORK( K ) = BLACS_PNUM( ICTXT , I , J )
198 K = K + 1
199 10 CONTINUE
200 20 CONTINUE
201
201
202 P = NPROW*NPCOL
203 NPROW = 1
204 NPCOL = P
205
206 CALL BLACS_GET( ICTXT , 10 , ONEDCONTEXT )
207 CALL BLACS_GRIDMAP( ONEDCONTEXT , IWORK , NPROW , NPROW , NPCOL )
208 CALL BLACS_GRIDINFO( ONEDCONTEXT , I , J , K , SELF )
209
210 * Simplifications :
211
212 IF( IRANGE.EQ.3 .AND. IL.EQ.1 .AND. IU.EQ.N )
212
213 $ IRANGE = 1
214
215 NEXT = MOD( SELF + 1 , P )
216 PREV = MOD( P + SELF - 1 , P )
217
218 * Compute squares of off - diagonals , splitting points and pivmin.
219 * Interleave diagonals and off - diagonals.
220
221 INDRW1 = MAX( 2*N , 4 )
222 INDRW2 = INDRW1 + 2*N
223 INDRIW1 = MAX( 2*N , 8 )
224 NSPLIT = 1
225 WORK( INDRW1 + 2*N ) = ZERO
226 PIVMIN = ONE
227
228 DO 30 I = 1 , N - 1
228
229 TMP1 = E( I )**2
230 J = 2*I
231 WORK( INDRW1 + J - 1 ) = D( I )
232 IF( ABS( D( I + 1 )*D( I ) )*ULP**2 + SAFEMN.GT.TMP1 ) THEN
232
233 ISPLIT( NSPLIT ) = I
234 NSPLIT = NSPLIT + 1
235 WORK( INDRW1 + J ) = ZERO
236 ELSE
236
237 WORK( INDRW1 + J ) = TMP1
238 PIVMIN = MAX( PIVMIN , TMP1 )
239 END IF
240 30 CONTINUE
240
241 WORK( INDRW1 + 2*N - 1 ) = D( N )
242 ISPLIT( NSPLIT ) = N
243 PIVMIN = PIVMIN*SAFEMN
244
245 * Compute Gershgorin interval[gl , gu] for entire matrix
246
247 GU = D( 1 )
248 GL = D( 1 )
249 TMP1 = ZERO
250
251 DO 40 I = 1 , N - 1
251
252 TMP2 = ABS( E( I ) )
253 GU = MAX( GU , D( I ) + TMP1 + TMP2 )
254 GL = MIN( GL , D( I ) - TMP1 - TMP2 )
255 TMP1 = TMP2
256 40 CONTINUE
256
257 GU = MAX( GU , D( N ) + TMP1 )
258 GL = MIN( GL , D( N ) - TMP1 )
259 TNORM = MAX( ABS( GL ) , ABS( GU ) )
260 GL = GL - FUDGE*TNORM*ULP*N - FUDGE*TWO*PIVMIN
261 GU = GU + FUDGE*TNORM*ULP*N + FUDGE*PIVMIN
262
263 IF( ABSTOL.LE.ZERO ) THEN
263
264 ATOLI = ULP*TNORM
265 ELSE
265
266 ATOLI = ABSTOL
267 END IF
268
269 * Find out if on an IEEE machine , the sign bit is the
270 * 32nd bit(Big Endian) or the 64th bit(Little Endian)
271
272 IF( IRANGE.EQ.1 .OR. NSPLIT.EQ.1 ) THEN
272
273 CALL PSLASNBT( IEFLAG )
274 ELSE
274
275 IEFLAG = 0
276 END IF
277 LEXTRA = 0
278 REXTRA = 0
279
280 * Form Initial Interval containing desired eigenvalues
281
282 IF( IRANGE.EQ.1 ) THEN
282
283 INITVL = GL
284 INITVU = GU
285 WORK( 1 ) = GL
286 WORK( 2 ) = GU
287 IWORK( 1 ) = 0
288 IWORK( 2 ) = N
289 IFRST = 1
290 ILAST = N
291 ELSE IF( IRANGE.EQ.2 ) THEN
291
292 IF( VL.GT.GL ) THEN
292
293 IF( IEFLAG.EQ.0 ) THEN
293
294 CALL PSLAPDCT ( VL , N , WORK( INDRW1 + 1 ) , PIVMIN , IFRST )
295 ELSE
295
296 CALL PSLAIECT( VL , N , WORK( INDRW1 + 1 ) , IFRST )
297 END IF
298 IFRST = IFRST + 1
299 INITVL = VL
300 ELSE
300
301 INITVL = GL
302 IFRST = 1
303 END IF
304 IF( VU.LT.GU ) THEN
304
305 IF( IEFLAG.EQ.0 ) THEN
305
306 CALL PSLAPDCT ( VU , N , WORK( INDRW1 + 1 ) , PIVMIN , ILAST )
307 ELSE
307
308 CALL PSLAIECT( VU , N , WORK( INDRW1 + 1 ) , ILAST )
309 END IF
310 INITVU = VU
311 ELSE
311
312 INITVU = GU
313 ILAST = N
314 END IF
315 WORK( 1 ) = INITVL
316 WORK( 2 ) = INITVU
317 IWORK( 1 ) = IFRST - 1
318 IWORK( 2 ) = ILAST
319 ELSE IF( IRANGE.EQ.3 ) THEN
319
320 WORK( 1 ) = GL
321 WORK( 2 ) = GU
322 IWORK( 1 ) = 0
323 IWORK( 2 ) = N
324 IWORK( 5 ) = IL - 1
325 IWORK( 6 ) = IU
326 CALL PSLAEBZ ( 0 , N , 2 , 1 , ATOLI , RELTOL , PIVMIN ,
327 $ WORK( INDRW1 + 1 ) , IWORK( 5 ) , WORK , IWORK , NINT ,
328 $ LSAVE , IEFLAG , IINFO )
329 IF( IINFO.NE.0 ) THEN
329
330 INFO = 3
331 GO TO 230
332 END IF
333 IF( NINT.GT.1 ) THEN
333
334 IF( IWORK( 5 ).EQ.IL - 1 ) THEN
334
335 WORK( 2 ) = WORK( 4 )
336 IWORK( 2 ) = IWORK( 4 )
337 ELSE
337
338 WORK( 1 ) = WORK( 3 )
339 IWORK( 1 ) = IWORK( 3 )
340 END IF
341 IF( IWORK( 1 ).LT.0 .OR. IWORK( 1 ).GT.IL - 1 .OR.
342 $ IWORK( 2 ).LE.MIN( IU - 1 , IWORK( 1 ) ) .OR.
343 $ IWORK( 2 ).GT.N ) THEN
344 INFO = 3
345 GO TO 230
346 END IF
347 END IF
348 LEXTRA = IL - 1 - IWORK( 1 )
349 REXTRA = IWORK( 2 ) - IU
350 INITVL = WORK( 1 )
351 INITVU = WORK( 2 )
352 IFRST = IL
353 ILAST = IU
354 END IF
355 * NVL = IFRST - 1
356 * NVU = ILAST
357 GL = INITVL
358 GU = INITVU
359 NGL = IWORK( 1 )
360 NGU = IWORK( 2 )
361 IM = 0
362 FOUND = 0
363 INDRIW2 = INDRIW1 + NGU - NGL
364 IEND = 0
365 IF( IFRST.GT.ILAST )
365
366 $ GO TO 100
367 IF( IFRST.EQ.1 .AND. ILAST.EQ.N )
367
368 $ IRANGE = 1
369
370 * Find Eigenvalues -- Loop Over Blocks
371
372 DO 90 JB = 1 , NSPLIT
372
373 IOFF = IEND
374 IBEGIN = IOFF + 1
375 IEND = ISPLIT( JB )
376 IN = IEND - IOFF
377 IF( JB.NE.1 ) THEN
377
378 IF( IRANGE.NE.1 ) THEN
378
379 FOUND = IM
380
381 * Find total number of eigenvalues found thus far
382
383 CALL IGSUM2D( ONEDCONTEXT , 'All' , ' ' , 1 , 1 , FOUND , 1 ,
384 $ - 1 , - 1 )
385 ELSE
385
386 FOUND = IOFF
387 END IF
388 END IF
389 * IF( SELF.GE.P )
390 * $ GO TO 30
391 IF( IN.NE.N ) THEN
392
393 * Compute Gershgorin interval[gl , gu] for split matrix
394
394
395 GU = D( IBEGIN )
396 GL = D( IBEGIN )
397 TMP1 = ZERO
398
399 DO 50 J = IBEGIN , IEND - 1
399
400 TMP2 = ABS( E( J ) )
401 GU = MAX( GU , D( J ) + TMP1 + TMP2 )
402 GL = MIN( GL , D( J ) - TMP1 - TMP2 )
403 TMP1 = TMP2
404 50 CONTINUE
405
405
406 GU = MAX( GU , D( IEND ) + TMP1 )
407 GL = MIN( GL , D( IEND ) - TMP1 )
408 BNORM = MAX( ABS( GL ) , ABS( GU ) )
409 GL = GL - FUDGE*BNORM*ULP*IN - FUDGE*PIVMIN
410 GU = GU + FUDGE*BNORM*ULP*IN + FUDGE*PIVMIN
411
412 * Compute ATOLI for the current submatrix
413
414 IF( ABSTOL.LE.ZERO ) THEN
414
415 ATOLI = ULP*BNORM
416 ELSE
416
417 ATOLI = ABSTOL
418 END IF
419
420 IF( GL.LT.INITVL ) THEN
420
421 GL = INITVL
422 IF( IEFLAG.EQ.0 ) THEN
422
423 CALL PSLAPDCT ( GL , IN , WORK( INDRW1 + 2*IOFF + 1 ) ,
424 $ PIVMIN , NGL )
425 ELSE
425
426 CALL PSLAIECT( GL , IN , WORK( INDRW1 + 2*IOFF + 1 ) , NGL )
427 END IF
428 ELSE
428
429 NGL = 0
430 END IF
431 IF( GU.GT.INITVU ) THEN
431
432 GU = INITVU
433 IF( IEFLAG.EQ.0 ) THEN
433
434 CALL PSLAPDCT ( GU , IN , WORK( INDRW1 + 2*IOFF + 1 ) ,
435 $ PIVMIN , NGU )
436 ELSE
436
437 CALL PSLAIECT( GU , IN , WORK( INDRW1 + 2*IOFF + 1 ) , NGU )
438 END IF
439 ELSE
439
440 NGU = IN
441 END IF
442 IF( NGL.GE.NGU )
442
443 $ GO TO 90
444 WORK( 1 ) = GL
445 WORK( 2 ) = GU
446 IWORK( 1 ) = NGL
447 IWORK( 2 ) = NGU
448 END IF
449 OFFSET = FOUND - NGL
450 BLKNO = JB
451
452 * Do a static partitioning of work so that each process
453 * has to find an(almost) equal number of eigenvalues
454
455 NCMP = NGU - NGL
456 ILOAD = NCMP / P
457 IREM = NCMP - ILOAD*P
458 ITMP1 = MOD( SELF - FOUND , P )
459 IF( ITMP1.LT.0 )
459
460 $ ITMP1 = ITMP1 + P
461 IF( ITMP1.LT.IREM ) THEN
461
462 IMYLOAD = ILOAD + 1
463 ELSE
463
464 IMYLOAD = ILOAD
465 END IF
466 IF( IMYLOAD.EQ.0 ) THEN
466
467 GO TO 90
468 ELSE IF( IN.EQ.1 ) THEN
468
469 WORK( INDRW2 + IM + 1 ) = WORK( INDRW1 + 2*IOFF + 1 )
470 IWORK( INDRIW1 + IM + 1 ) = BLKNO
471 IWORK( INDRIW2 + IM + 1 ) = OFFSET + 1
472 IM = IM + 1
473 GO TO 90
474 ELSE
474
475 INXTLOAD = ILOAD
476 ITMP2 = MOD( SELF + 1 - FOUND , P )
477 IF( ITMP2.LT.0 )
477
478 $ ITMP2 = ITMP2 + P
479 IF( ITMP2.LT.IREM )
479
480 $ INXTLOAD = INXTLOAD + 1
481 LREQ = NGL + ITMP1*ILOAD + MIN( IREM , ITMP1 )
482 RREQ = LREQ + IMYLOAD
483 IWORK( 5 ) = LREQ
484 IWORK( 6 ) = RREQ
485 TMP1 = WORK( 1 )
486 ITMP1 = IWORK( 1 )
487 CALL PSLAEBZ ( 1 , IN , 1 , 1 , ATOLI , RELTOL , PIVMIN ,
488 $ WORK( INDRW1 + 2*IOFF + 1 ) , IWORK( 5 ) , WORK ,
489 $ IWORK , NINT , LSAVE , IEFLAG , IINFO )
490 ALPHA = WORK( 1 )
491 BETA = WORK( 2 )
492 NALPHA = IWORK( 1 )
493 NBETA = IWORK( 2 )
494 DSEND = BETA
495 IF( NBETA.GT.RREQ + INXTLOAD ) THEN
495
496 NBETA = RREQ
497 DSEND = ALPHA
498 END IF
499 LAST = MOD( FOUND + MIN( NGU - NGL , P ) - 1 , P )
500 IF( LAST.LT.0 )
500
501 $ LAST = LAST + P
502 IF( SELF.NE.LAST ) THEN
502
503 CALL SGESD2D( ONEDCONTEXT , 1 , 1 , DSEND , 1 , 0 , NEXT )
504 CALL IGESD2D( ONEDCONTEXT , 1 , 1 , NBETA , 1 , 0 , NEXT )
505 END IF
506 IF( SELF.NE.MOD( FOUND , P ) ) THEN
506
507 CALL SGERV2D( ONEDCONTEXT , 1 , 1 , DRECV , 1 , 0 , PREV )
508 CALL IGERV2D( ONEDCONTEXT , 1 , 1 , IRECV , 1 , 0 , PREV )
509 ELSE
509
510 DRECV = TMP1
511 IRECV = ITMP1
512 END IF
513 WORK( 1 ) = MAX( LSAVE , DRECV )
514 IWORK( 1 ) = IRECV
515 ALPHA = MAX( ALPHA , WORK( 1 ) )
516 NALPHA = MAX( NALPHA , IRECV )
517 IF( BETA - ALPHA.LE.MAX( ATOLI , RELTOL*MAX( ABS( ALPHA ) ,
518 $ ABS( BETA ) ) ) ) THEN
519 MID = HALF*( ALPHA + BETA )
520 DO 60 J = OFFSET + NALPHA + 1 , OFFSET + NBETA
521 WORK( INDRW2 + IM + 1 ) = MID
522 IWORK( INDRIW1 + IM + 1 ) = BLKNO
523 IWORK( INDRIW2 + IM + 1 ) = J
524 IM = IM + 1
525 60 CONTINUE
525
526 WORK( 2 ) = ALPHA
527 IWORK( 2 ) = NALPHA
528 END IF
529 END IF
530 NEIGINT = IWORK( 2 ) - IWORK( 1 )
531 IF( NEIGINT.LE.0 )
531
532 $ GO TO 90
533
534 * Call the main computational routine
535
536 CALL PSLAEBZ ( 2 , IN , NEIGINT , 1 , ATOLI , RELTOL , PIVMIN ,
537 $ WORK( INDRW1 + 2*IOFF + 1 ) , IWORK , WORK , IWORK ,
538 $ IOUT , LSAVE , IEFLAG , IINFO )
539 IF( IINFO.NE.0 ) THEN
539
540 INFO = 1
541 END IF
542 DO 80 I = 1 , IOUT
542
543 MID = HALF*( WORK( 2*I - 1 ) + WORK( 2*I ) )
544 IF( I.GT.IOUT - IINFO )
544
545 $ BLKNO = - BLKNO
546 DO 70 J = OFFSET + IWORK( 2*I - 1 ) + 1 ,
547 $ OFFSET + IWORK( 2*I )
548 WORK( INDRW2 + IM + 1 ) = MID
549 IWORK( INDRIW1 + IM + 1 ) = BLKNO
550 IWORK( INDRIW2 + IM + 1 ) = J
551 IM = IM + 1
552 70 CONTINUE
553 80 CONTINUE
554 90 CONTINUE
555
556 * Find out total number of eigenvalues computed
557
558 100 CONTINUE
559 M = IM
560 CALL IGSUM2D( ONEDCONTEXT , 'ALL' , ' ' , 1 , 1 , M , 1 , - 1 , - 1 )
561
562 * Move the eigenvalues found to their final destinations
563
564 DO 130 I = 1 , P
564
565 IF( SELF.EQ.I - 1 ) THEN
565
566 CALL IGEBS2D( ONEDCONTEXT , 'ALL' , ' ' , 1 , 1 , IM , 1 )
567 IF( IM.NE.0 ) THEN
567
568 CALL IGEBS2D( ONEDCONTEXT , 'ALL' , ' ' , IM , 1 ,
569 $ IWORK( INDRIW2 + 1 ) , IM )
570 CALL SGEBS2D( ONEDCONTEXT , 'ALL' , ' ' , IM , 1 ,
571 $ WORK( INDRW2 + 1 ) , IM )
572 CALL IGEBS2D( ONEDCONTEXT , 'ALL' , ' ' , IM , 1 ,
573 $ IWORK( INDRIW1 + 1 ) , IM )
574 DO 110 J = 1 , IM
574
575 W( IWORK( INDRIW2 + J ) ) = WORK( INDRW2 + J )
576 IBLOCK( IWORK( INDRIW2 + J ) ) = IWORK( INDRIW1 + J )
577 110 CONTINUE
577
578 END IF
579 ELSE
579
580 CALL IGEBR2D( ONEDCONTEXT , 'ALL' , ' ' , 1 , 1 , TORECV , 1 , 0 ,
581 $ I - 1 )
582 IF( TORECV.NE.0 ) THEN
582
583 CALL IGEBR2D( ONEDCONTEXT , 'ALL' , ' ' , TORECV , 1 , IWORK ,
584 $ TORECV , 0 , I - 1 )
585 CALL SGEBR2D( ONEDCONTEXT , 'ALL' , ' ' , TORECV , 1 , WORK ,
586 $ TORECV , 0 , I - 1 )
587 CALL IGEBR2D( ONEDCONTEXT , 'ALL' , ' ' , TORECV , 1 ,
588 $ IWORK( N + 1 ) , TORECV , 0 , I - 1 )
589 DO 120 J = 1 , TORECV
589
590 W( IWORK( J ) ) = WORK( J )
591 IBLOCK( IWORK( J ) ) = IWORK( N + J )
592 120 CONTINUE
592
593 END IF
594 END IF
595 130 CONTINUE
596 IF( NSPLIT.GT.1 .AND. IORDER.EQ.1 ) THEN
597
598 * Sort the eigenvalues
599
599
600 DO 140 I = 1 , M
600
601 IWORK( M + I ) = I
602 140 CONTINUE
602
603 CALL SLASRT2 ( 'I' , M , W , IWORK( M + 1 ) , IINFO )
604 DO 150 I = 1 , M
604
605 IWORK( I ) = IBLOCK( I )
606 150 CONTINUE
606
607 DO 160 I = 1 , M
607
608 IBLOCK( I ) = IWORK( IWORK( M + I ) )
609 160 CONTINUE
610 END IF
611 IF( IRANGE.EQ.3 .AND.( LEXTRA.GT.0 .OR. REXTRA.GT.0 ) ) THEN
612
613 * Discard unwanted eigenvalues(occurs only when RANGE = 'I' ,
614 * and eigenvalues IL , and / or IU are in a cluster)
615
615
616 DO 170 I = 1 , M
616
617 WORK( I ) = W( I )
618 IWORK( I ) = I
619 IWORK( M + I ) = I
620 170 CONTINUE
620
621 DO 190 I = 1 , LEXTRA
621
622 ITMP1 = I
623 DO 180 J = I + 1 , M
623
624 IF( WORK( J ).LT.WORK( ITMP1 ) ) THEN
624
625 ITMP1 = J
626 END IF
627 180 CONTINUE
627
628 TMP1 = WORK( I )
629 WORK( I ) = WORK( ITMP1 )
630 WORK( ITMP1 ) = TMP1
631 IWORK( IWORK( M + ITMP1 ) ) = I
632 IWORK( IWORK( M + I ) ) = ITMP1
633 ITMP2 = IWORK( M + I )
634 IWORK( M + I ) = IWORK( M + ITMP1 )
635 IWORK( M + ITMP1 ) = ITMP2
636 190 CONTINUE
636
637 DO 210 I = 1 , REXTRA
637
638 ITMP1 = M - I + 1
639 DO 200 J = M - I , LEXTRA + 1 , - 1
639
640 IF( WORK( J ).GT.WORK( ITMP1 ) ) THEN
640
641 ITMP1 = J
642 END IF
643 200 CONTINUE
643
644 TMP1 = WORK( M - I + 1 )
645 WORK( M - I + 1 ) = WORK( ITMP1 )
646 WORK( ITMP1 ) = TMP1
647 IWORK( IWORK( M + ITMP1 ) ) = M - I + 1
648 IWORK( IWORK( 2*M - I + 1 ) ) = ITMP1
649 ITMP2 = IWORK( 2*M - I + 1 )
650 IWORK( 2*M - I + 1 ) = IWORK( M + ITMP1 )
651 IWORK( M + ITMP1 ) = ITMP2
652 * IWORK( ITMP1 ) = 1
653 210 CONTINUE
653
654 J = 0
655 DO 220 I = 1 , M
655
656 IF( IWORK( I ).GT.LEXTRA .AND. IWORK( I ).LE.M - REXTRA ) THEN
656
657 J = J + 1
658 W( J ) = WORK( IWORK( I ) )
659 IBLOCK( J ) = IBLOCK( I )
660 END IF
661 220 CONTINUE
661
662 M = M - LEXTRA - REXTRA
663 END IF
664 IF( M.NE.ILAST - IFRST + 1 ) THEN
664
665 INFO = 2
666 END IF
667
668 230 CONTINUE
669 CALL BLACS_FREEBUFF( ONEDCONTEXT , 1 )
670 CALL BLACS_GRIDEXIT( ONEDCONTEXT )
671 RETURN
672
673 * End of PSSTEBZ
674
675 END
676 59
133
|
|
Variables in Routine PSSTEBZ()
| Summary Report |
| Data Type | Quantity | Size(byte) |
| CHARACTER | 2 | 2 |
| INTEGER | 80 | 336 |
| LOGICAL | 2 | 2 |
| REAL | 32 | 128 |
| TOTAL | 116 | 468 |
List of Variables
CHARACTER
INTEGER
| BIGNUM | BLACS_PNUM | BLKNO | BLOCK_CYCLIC_2D | CSRC_ |
| CTXT_ | DESCMULT | DLEN_ | DTYPE_ | FOUND |
| I | IBEGIN | IBLOCK | ICTXT | IDUM( 5, 2 ) |
| IEFLAG | IEND | IFRST | IINFO | IL |
| ILAST | ILOAD | IM | IMYLOAD | IN |
| INDRIW1 | INDRIW2 | INDRW1 | INDRW2 | INFO |
| INXTLOAD | IOFF | IORDER | IOUT | IRANGE |
| IRECV | IREM | ISPLIT | ITMP1 | ITMP2 |
| IU | IWORK | J | JB | K |
| LAST | LEXTRA | LIWORK | LLD_ | LREQ |
| LWORK | M | M_ | MB_ | MYCOL |
| MYROW | N | N_ | NALPHA | NB_ |
| NBETA | NCMP | NEIGINT | NEXT | NGL |
| NGLOB | NGU | NINT | NPCOL | NPROW |
| NSPLIT | OFFSET | ONEDCONTEXT | P | PREV |
| REXTRA | RREQ | RSRC_ | SELF | TORECV |
LOGICAL
REAL
| ABSTOL | ALPHA | ATOLI | BETA | BNORM |
| DRECV | DSEND | FIVE | FUDGE | GL |
| GU | HALF | INITVL | INITVU | LSAVE |
| MID | ONE | PIVMIN | PSLAMCH | RELFAC |
| RELTOL | SAFEMN | TMP1 | TMP2 | TNORM |
| TWO | ULP | VL | VU | W |
| WORK | ZERO | | | |
Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence | | - | | - | - | | ALPHA | <--- | WORKALPHA = WORK( 1 ){2ALPHA = MAX( ALPHA, WORK( 1 ) )}, ALPHAALPHA = MAX( ALPHA, WORK( 1 ) ) |
| ATOLI | <--- | ABSTOLATOLI = ABSTOL{2ATOLI = ABSTOL}, TNORMATOLI = ULP*TNORM, ULPATOLI = ULP*TNORM{2ATOLI = ULP*BNORM}, BNORMATOLI = ULP*BNORM |
| BETA | <--- | WORKBETA = WORK( 2 ) |
| BLKNO | <--- | JBBLKNO = JB |
| BNORM | <--- | GLBNORM = MAX( ABS( GL ), ABS( GU ) ), GUBNORM = MAX( ABS( GL ), ABS( GU ) ) |
| DRECV | <--- | TMP1DRECV = TMP1 |
| DSEND | <--- | ALPHADSEND = ALPHA, BETADSEND = BETA |
| FOUND | <--- | IMFOUND = IM, IOFFFOUND = IOFF |
| GL | <--- | TMP1GL = MIN( GL, D( I )-TMP1-TMP2 ){2GL = MIN( GL, D( N )-TMP1 ), 3GL = MIN( GL, D( J )-TMP1-TMP2 ), 4GL = MIN( GL, D( IEND )-TMP1 )}, TMP2GL = MIN( GL, D( I )-TMP1-TMP2 ){2GL = MIN( GL, D( J )-TMP1-TMP2 )}, TNORMGL = GL - FUDGE*TNORM*ULP*N - FUDGE*TWO*PIVMIN, TWOGL = GL - FUDGE*TNORM*ULP*N - FUDGE*TWO*PIVMIN, ULPGL = GL - FUDGE*TNORM*ULP*N - FUDGE*TWO*PIVMIN{2GL = GL - FUDGE*BNORM*ULP*IN - FUDGE*PIVMIN}, FUDGEGL = GL - FUDGE*TNORM*ULP*N - FUDGE*TWO*PIVMIN{2GL = GL - FUDGE*BNORM*ULP*IN - FUDGE*PIVMIN}, GLGL = MIN( GL, D( I )-TMP1-TMP2 ){2GL = MIN( GL, D( N )-TMP1 ), 3GL = GL - FUDGE*TNORM*ULP*N - FUDGE*TWO*PIVMIN, 4GL = MIN( GL, D( J )-TMP1-TMP2 ), 5GL = MIN( GL, D( IEND )-TMP1 ), 6GL = GL - FUDGE*BNORM*ULP*IN - FUDGE*PIVMIN}, IGL = MIN( GL, D( I )-TMP1-TMP2 ), IBEGINGL = D( IBEGIN ), IENDGL = MIN( GL, D( IEND )-TMP1 ), INGL = GL - FUDGE*BNORM*ULP*IN - FUDGE*PIVMIN, INITVLGL = INITVL{2GL = INITVL}, JGL = MIN( GL, D( J )-TMP1-TMP2 ), NGL = MIN( GL, D( N )-TMP1 ){2GL = GL - FUDGE*TNORM*ULP*N - FUDGE*TWO*PIVMIN}, BNORMGL = GL - FUDGE*BNORM*ULP*IN - FUDGE*PIVMIN, PIVMINGL = GL - FUDGE*TNORM*ULP*N - FUDGE*TWO*PIVMIN{2GL = GL - FUDGE*BNORM*ULP*IN - FUDGE*PIVMIN} |
| GU | <--- | TMP1GU = MAX( GU, D( I )+TMP1+TMP2 ){2GU = MAX( GU, D( N )+TMP1 ), 3GU = MAX( GU, D( J )+TMP1+TMP2 ), 4GU = MAX( GU, D( IEND )+TMP1 )}, TMP2GU = MAX( GU, D( I )+TMP1+TMP2 ){2GU = MAX( GU, D( J )+TMP1+TMP2 )}, TNORMGU = GU + FUDGE*TNORM*ULP*N + FUDGE*PIVMIN, ULPGU = GU + FUDGE*TNORM*ULP*N + FUDGE*PIVMIN{2GU = GU + FUDGE*BNORM*ULP*IN + FUDGE*PIVMIN}, FUDGEGU = GU + FUDGE*TNORM*ULP*N + FUDGE*PIVMIN{2GU = GU + FUDGE*BNORM*ULP*IN + FUDGE*PIVMIN}, GUGU = MAX( GU, D( I )+TMP1+TMP2 ){2GU = MAX( GU, D( N )+TMP1 ), 3GU = GU + FUDGE*TNORM*ULP*N + FUDGE*PIVMIN, 4GU = MAX( GU, D( J )+TMP1+TMP2 ), 5GU = MAX( GU, D( IEND )+TMP1 ), 6GU = GU + FUDGE*BNORM*ULP*IN + FUDGE*PIVMIN}, IGU = MAX( GU, D( I )+TMP1+TMP2 ), IBEGINGU = D( IBEGIN ), IENDGU = MAX( GU, D( IEND )+TMP1 ), INGU = GU + FUDGE*BNORM*ULP*IN + FUDGE*PIVMIN, INITVUGU = INITVU{2GU = INITVU}, JGU = MAX( GU, D( J )+TMP1+TMP2 ), NGU = MAX( GU, D( N )+TMP1 ){2GU = GU + FUDGE*TNORM*ULP*N + FUDGE*PIVMIN}, BNORMGU = GU + FUDGE*BNORM*ULP*IN + FUDGE*PIVMIN, PIVMINGU = GU + FUDGE*TNORM*ULP*N + FUDGE*PIVMIN{2GU = GU + FUDGE*BNORM*ULP*IN + FUDGE*PIVMIN} |
| I | <--- | REXTRADO 210 I = 1, REXTRA, IOUTDO 80 I = 1, IOUT, LEXTRADO 190 I = 1, LEXTRA, MDO 140 I = 1, M{2DO 150 I = 1, M, 3DO 160 I = 1, M, 4DO 170 I = 1, M, 5DO 220 I = 1, M}, NDO 30 I = 1, N - 1{2DO 40 I = 1, N - 1}, NPROWDO 20 I = 0, NPROW - 1, PDO 130 I = 1, P |
| IBEGIN | <--- | IOFFIBEGIN = IOFF + 1 |
| IBLOCK | <--- | IIBLOCK( I ) = IWORK( IWORK( M+I ) ){2IBLOCK( J ) = IBLOCK( I )}, IBLOCKIBLOCK( J ) = IBLOCK( I ), INDRIW1IBLOCK( IWORK( INDRIW2+J ) ) = IWORK( INDRIW1+J ), IWORKIBLOCK( IWORK( INDRIW2+J ) ) = IWORK( INDRIW1+J ){2IBLOCK( IWORK( J ) ) = IWORK( N+J ), 3IBLOCK( I ) = IWORK( IWORK( M+I ) )}, JIBLOCK( IWORK( INDRIW2+J ) ) = IWORK( INDRIW1+J ){2IBLOCK( IWORK( J ) ) = IWORK( N+J )}, MIBLOCK( I ) = IWORK( IWORK( M+I ) ), NIBLOCK( IWORK( J ) ) = IWORK( N+J ) |
| IDUM | <--- | ILIDUM( 4, 1 ) = IL, IUIDUM( 5, 1 ) = IU, NIDUM( 3, 1 ) = N, ORDERIDUM( 2, 1 ) = ICHAR( ORDER ), RANGEIDUM( 1, 1 ) = ICHAR( RANGE ) |
| IEND | <--- | ISPLITIEND = ISPLIT( JB ), JBIEND = ISPLIT( JB ) |
| IFRST | <--- | IFRSTIFRST = IFRST + 1, ILIFRST = IL |
| ILAST | <--- | IUILAST = IU, NILAST = N{2ILAST = N} |
| ILOAD | <--- | NCMPILOAD = NCMP / P, PILOAD = NCMP / P |
| IM | <--- | IMIM = IM + 1{2IM = IM + 1, 3IM = IM + 1} |
| IMYLOAD | <--- | ILOADIMYLOAD = ILOAD + 1{2IMYLOAD = ILOAD} |
| IN | <--- | IENDIN = IEND - IOFF, IOFFIN = IEND - IOFF |
| INDRIW1 | <--- | NINDRIW1 = MAX( 2*N, 8 ) |
| INDRIW2 | <--- | INDRIW1INDRIW2 = INDRIW1 + NGU - NGL, NGLINDRIW2 = INDRIW1 + NGU - NGL, NGUINDRIW2 = INDRIW1 + NGU - NGL |
| INDRW1 | <--- | NINDRW1 = MAX( 2*N, 4 ) |
| INDRW2 | <--- | INDRW1INDRW2 = INDRW1 + 2*N, NINDRW2 = INDRW1 + 2*N |
| INFO | <--- | DESCMULTINFO = -INFO / DESCMULT, INFOINFO = -INFO / DESCMULT{2INFO = -INFO} |
| INITVL | <--- | VLINITVL = VL, WORKINITVL = WORK( 1 ), GLINITVL = GL{2INITVL = GL} |
| INITVU | <--- | VUINITVU = VU, WORKINITVU = WORK( 2 ), GUINITVU = GU{2INITVU = GU} |
| INXTLOAD | <--- | ILOADINXTLOAD = ILOAD |
| IOFF | <--- | IENDIOFF = IEND |
| IRECV | <--- | ITMP1IRECV = ITMP1 |
| IREM | <--- | ILOADIREM = NCMP - ILOAD*P, NCMPIREM = NCMP - ILOAD*P, PIREM = NCMP - ILOAD*P |
| ISPLIT | <--- | IISPLIT( NSPLIT ) = I, NISPLIT( NSPLIT ) = N |
| ITMP1 | <--- | SELFITMP1 = MOD( SELF-FOUND, P ), FOUNDITMP1 = MOD( SELF-FOUND, P ), IITMP1 = I{2ITMP1 = M - I + 1}, IWORKITMP1 = IWORK( 1 ), JITMP1 = J{2ITMP1 = J}, MITMP1 = M - I + 1, PITMP1 = MOD( SELF-FOUND, P ) |
| ITMP2 | <--- | SELFITMP2 = MOD( SELF+1-FOUND, P ), FOUNDITMP2 = MOD( SELF+1-FOUND, P ), IITMP2 = IWORK( M+I ){2ITMP2 = IWORK( 2*M-I+1 )}, IWORKITMP2 = IWORK( M+I ){2ITMP2 = IWORK( 2*M-I+1 )}, MITMP2 = IWORK( M+I ){2ITMP2 = IWORK( 2*M-I+1 )}, PITMP2 = MOD( SELF+1-FOUND, P ) |
| IWORK | <--- | RREQIWORK( 6 ) = RREQ, IIWORK( K ) = BLACS_PNUM( ICTXT, I, J ){2IWORK( M+I ) = I, 3IWORK( I ) = IBLOCK( I ), 4IWORK( I ) = I, 5IWORK( M+I ) = I, 6IWORK( IWORK( M+ITMP1 ) ) = I, 7IWORK( IWORK( M+ITMP1 ) ) = M - I + 1}, IBLOCKIWORK( I ) = IBLOCK( I ), ICTXTIWORK( K ) = BLACS_PNUM( ICTXT, I, J ), IFRSTIWORK( 1 ) = IFRST - 1, ILIWORK( 5 ) = IL - 1, ILASTIWORK( 2 ) = ILAST, IRECVIWORK( 1 ) = IRECV, ITMP1IWORK( IWORK( M+I ) ) = ITMP1{2IWORK( M+I ) = IWORK( M+ITMP1 ), 3IWORK( IWORK( 2*M-I+1 ) ) = ITMP1, 4IWORK( 2*M-I+1 ) = IWORK( M+ITMP1 )}, ITMP2IWORK( M+ITMP1 ) = ITMP2{2IWORK( M+ITMP1 ) = ITMP2}, IUIWORK( 6 ) = IU, IWORKIWORK( 2 ) = IWORK( 4 ){2IWORK( 1 ) = IWORK( 3 ), 3IWORK( M+I ) = IWORK( M+ITMP1 ), 4IWORK( 2*M-I+1 ) = IWORK( M+ITMP1 )}, JIWORK( K ) = BLACS_PNUM( ICTXT, I, J ){2IWORK( INDRIW2+IM+1 ) = J, 3IWORK( INDRIW2+IM+1 ) = J}, BLACS_PNUMIWORK( K ) = BLACS_PNUM( ICTXT, I, J ), LREQIWORK( 5 ) = LREQ, MIWORK( M+I ) = IWORK( M+ITMP1 ){2IWORK( IWORK( M+ITMP1 ) ) = M - I + 1, 3IWORK( 2*M-I+1 ) = IWORK( M+ITMP1 )}, BLKNOIWORK( INDRIW1+IM+1 ) = BLKNO{2IWORK( INDRIW1+IM+1 ) = BLKNO, 3IWORK( INDRIW1+IM+1 ) = BLKNO}, NIWORK( 1 ) = MAX( 4*N, 14, NPROW*NPCOL ){2IWORK( 2 ) = N, 3IWORK( 2 ) = N}, NALPHAIWORK( 2 ) = NALPHA, NGLIWORK( 1 ) = NGL, NGUIWORK( 2 ) = NGU, NPCOLIWORK( 1 ) = MAX( 4*N, 14, NPROW*NPCOL ), NPROWIWORK( 1 ) = MAX( 4*N, 14, NPROW*NPCOL ), OFFSETIWORK( INDRIW2+IM+1 ) = OFFSET + 1 |
| J | <--- | TORECVDO 120 J = 1, TORECV, IJ = 2*I{2DO 70 J = OFFSET + IWORK( 2*I-1 ) + 1,, 3DO 180 J = I + 1, M, 4DO 200 J = M - I, LEXTRA + 1, -1}, IBEGINDO 50 J = IBEGIN, IEND - 1, IENDDO 50 J = IBEGIN, IEND - 1, IMDO 110 J = 1, IM, IWORKDO 70 J = OFFSET + IWORK( 2*I-1 ) + 1,, JJ = J + 1, LEXTRADO 200 J = M - I, LEXTRA + 1, -1, MDO 180 J = I + 1, M{2DO 200 J = M - I, LEXTRA + 1, -1}, NALPHADO 60 J = OFFSET + NALPHA + 1, OFFSET + NBETA, NBETADO 60 J = OFFSET + NALPHA + 1, OFFSET + NBETA, NPCOLDO 10 J = 0, NPCOL - 1, OFFSETDO 60 J = OFFSET + NALPHA + 1, OFFSET + NBETA{2DO 70 J = OFFSET + IWORK( 2*I-1 ) + 1,} |
| JB | <--- | NSPLITDO 90 JB = 1, NSPLIT |
| K | <--- | KK = K + 1 |
| LAST | <--- | FOUNDLAST = MOD( FOUND+MIN( NGU-NGL, P )-1, P ), NGLLAST = MOD( FOUND+MIN( NGU-NGL, P )-1, P ), NGULAST = MOD( FOUND+MIN( NGU-NGL, P )-1, P ), PLAST = MOD( FOUND+MIN( NGU-NGL, P )-1, P ) |
| LEXTRA | <--- | ILLEXTRA = IL - 1 - IWORK( 1 ), IWORKLEXTRA = IL - 1 - IWORK( 1 ) |
| LREQ | <--- | ILOADLREQ = NGL + ITMP1*ILOAD + MIN( IREM, ITMP1 ), IREMLREQ = NGL + ITMP1*ILOAD + MIN( IREM, ITMP1 ), ITMP1LREQ = NGL + ITMP1*ILOAD + MIN( IREM, ITMP1 ), NGLLREQ = NGL + ITMP1*ILOAD + MIN( IREM, ITMP1 ) |
| M | <--- | REXTRAM = M - LEXTRA - REXTRA, IMM = IM, LEXTRAM = M - LEXTRA - REXTRA, MM = M - LEXTRA - REXTRA |
| MID | <--- | WORKMID = HALF*( WORK( 2*I-1 )+WORK( 2*I ) ), ALPHAMID = HALF*( ALPHA+BETA ), HALFMID = HALF*( ALPHA+BETA ){2MID = HALF*( WORK( 2*I-1 )+WORK( 2*I ) )}, IMID = HALF*( WORK( 2*I-1 )+WORK( 2*I ) ), BETAMID = HALF*( ALPHA+BETA ) |
| NALPHA | <--- | IRECVNALPHA = MAX( NALPHA, IRECV ), IWORKNALPHA = IWORK( 1 ), NALPHANALPHA = MAX( NALPHA, IRECV ) |
| NBETA | <--- | RREQNBETA = RREQ, IWORKNBETA = IWORK( 2 ) |
| NCMP | <--- | NGLNCMP = NGU - NGL, NGUNCMP = NGU - NGL |
| NEIGINT | <--- | IWORKNEIGINT = IWORK( 2 ) - IWORK( 1 ) |
| NEXT | <--- | SELFNEXT = MOD( SELF+1, P ), PNEXT = MOD( SELF+1, P ) |
| NGL | <--- | IWORKNGL = IWORK( 1 ) |
| NGU | <--- | INNGU = IN, IWORKNGU = IWORK( 2 ) |
| NPCOL | <--- | PNPCOL = P |
| NSPLIT | <--- | NSPLITNSPLIT = NSPLIT + 1 |
| OFFSET | <--- | FOUNDOFFSET = FOUND - NGL, NGLOFFSET = FOUND - NGL |
| P | <--- | NPCOLP = NPROW*NPCOL, NPROWP = NPROW*NPCOL |
| PIVMIN | <--- | SAFEMNPIVMIN = PIVMIN*SAFEMN, TMP1PIVMIN = MAX( PIVMIN, TMP1 ), ONEPIVMIN = ONE, PIVMINPIVMIN = MAX( PIVMIN, TMP1 ){2PIVMIN = PIVMIN*SAFEMN} |
| PREV | <--- | SELFPREV = MOD( P+SELF-1, P ), PPREV = MOD( P+SELF-1, P ) |
| RELTOL | <--- | ULPRELTOL = ULP*RELFAC, RELFACRELTOL = ULP*RELFAC |
| REXTRA | <--- | IUREXTRA = IWORK( 2 ) - IU, IWORKREXTRA = IWORK( 2 ) - IU |
| RREQ | <--- | IMYLOADRREQ = LREQ + IMYLOAD, LREQRREQ = LREQ + IMYLOAD |
| SAFEMN | <--- | ICTXTSAFEMN = PSLAMCH( ICTXT, 'S' ), PSLAMCHSAFEMN = PSLAMCH( ICTXT, 'S' ) |
| TMP1 | <--- | TMP2TMP1 = TMP2{2TMP1 = TMP2}, WORKTMP1 = WORK( 1 ){2TMP1 = WORK( I ), 3TMP1 = WORK( M-I+1 )}, ZEROTMP1 = ZERO{2TMP1 = ZERO}, ITMP1 = E( I )**2{2TMP1 = WORK( I ), 3TMP1 = WORK( M-I+1 )}, MTMP1 = WORK( M-I+1 ) |
| TMP2 | <--- | ITMP2 = ABS( E( I ) ), JTMP2 = ABS( E( J ) ) |
| TNORM | <--- | GLTNORM = MAX( ABS( GL ), ABS( GU ) ), GUTNORM = MAX( ABS( GL ), ABS( GU ) ) |
| ULP | <--- | ICTXTULP = PSLAMCH( ICTXT, 'P' ), PULP = PSLAMCH( ICTXT, 'P' ), PSLAMCHULP = PSLAMCH( ICTXT, 'P' ) |
| W | <--- | WORKW( IWORK( INDRIW2+J ) ) = WORK( INDRW2+J ){2W( IWORK( J ) ) = WORK( J ), 3W( J ) = WORK( IWORK( I ) )}, IW( J ) = WORK( IWORK( I ) ), INDRW2W( IWORK( INDRIW2+J ) ) = WORK( INDRW2+J ), IWORKW( J ) = WORK( IWORK( I ) ), JW( IWORK( INDRIW2+J ) ) = WORK( INDRW2+J ){2W( IWORK( J ) ) = WORK( J )} |
| WORK | <--- | ABSTOLWORK( 1 ) = ABSTOL, TMP1WORK( INDRW1+J ) = TMP1{2WORK( ITMP1 ) = TMP1, 3WORK( ITMP1 ) = TMP1}, VLWORK( 2 ) = VL, VUWORK( 3 ) = VU, WWORK( I ) = W( I ), WORKWORK( 2 ) = WORK( 4 ){2WORK( 1 ) = WORK( 3 ), 3WORK( INDRW2+IM+1 ) = WORK( INDRW1+2*IOFF+1 ), 4WORK( I ) = WORK( ITMP1 ), 5WORK( M-I+1 ) = WORK( ITMP1 )}, ZEROWORK( 2 ) = ZERO{2WORK( 3 ) = ZERO, 3WORK( INDRW1+2*N ) = ZERO, 4WORK( INDRW1+J ) = ZERO}, DRECVWORK( 1 ) = MAX( LSAVE, DRECV ), ALPHAWORK( 2 ) = ALPHA, GLWORK( 1 ) = GL{2WORK( 1 ) = GL, 3WORK( 1 ) = GL}, GUWORK( 2 ) = GU{2WORK( 2 ) = GU, 3WORK( 2 ) = GU}, IWORK( INDRW1+J-1 ) = D( I ){2WORK( I ) = W( I )}, INDRW1WORK( INDRW2+IM+1 ) = WORK( INDRW1+2*IOFF+1 ), INITVLWORK( 1 ) = INITVL, INITVUWORK( 2 ) = INITVU, IOFFWORK( INDRW2+IM+1 ) = WORK( INDRW1+2*IOFF+1 ), ITMP1WORK( I ) = WORK( ITMP1 ){2WORK( M-I+1 ) = WORK( ITMP1 )}, LSAVEWORK( 1 ) = MAX( LSAVE, DRECV ), MIDWORK( INDRW2+IM+1 ) = MID{2WORK( INDRW2+IM+1 ) = MID}, NWORK( 1 ) = REAL( MAX( 5*N, 7 ) ){2WORK( INDRW1+2*N-1 ) = D( N )} |
|
|
Analysis elements of the routine PSSTEBZ()
Put the mouse over each element to display detailed matching information
 Assigned variables |
| | | ALPHA , ATOLI , BETA , BIGNUM , BLKNO , BLOCK_CYCLIC_2D , BNORM , CSRC_ , CTXT_ , DESCMULT , DLEN_ , DRECV , DSEND , DTYPE_ , FIVE , FOUND , FUDGE , GL , GU , HALF , I , IBEGIN , IDUM , IEFLAG , IEND , IFRST , ILAST , ILOAD , IM , IMYLOAD , IN , INDRIW1 , INDRIW2 , INDRW1 , INDRW2 , INFO , INITVL , INITVU , INXTLOAD , IOFF , IORDER , IRANGE , IRECV , IREM , ITMP1 , ITMP2 , IWORK , J , JB , K , LAST , LEXTRA , LLD_ , LQUERY , LREQ , M , M_ , MB_ , MID , N , N_ , NALPHA , NB_ , NBETA , NCMP , NEIGINT , NEXT , NGL , NGLOB , NGU , NPCOL , NPROW , NSPLIT , OFFSET , ONE , P , PIVMIN , PREV , RANGE , RELFAC , RELTOL , REXTRA , RREQ , RSRC_ , SAFEMN , TMP1 , TMP2 , TNORM , TWO , ULP , WORK , ZERO |
|
| Active variables |
| | | ABSTOL , ALPHA , ATOLI , BETA , BIGNUM , BLACS_PNUM , BLKNO , BLOCK_CYCLIC_2D , BNORM , CSRC_ , CTXT_ , D , DESCMULT , DLEN_ , DRECV , DSEND , DTYPE_ , E , FIVE , FOUND , FUDGE , GL , GU , HALF , I , IBEGIN , IBLOCK , ICTXT , IDUM , IEFLAG , IEND , IFRST , IINFO , IL , ILAST , ILOAD , IM , IMYLOAD , IN , INDRIW1 , INDRIW2 , INDRW1 , INDRW2 , INFO , INITVL , INITVU , INXTLOAD , IOFF , IORDER , IOUT , IRANGE , IRECV , IREM , ISPLIT , ITMP1 , ITMP2 , IU , IWORK , J , JB , K , LAST , LEXTRA , LIWORK , LLD_ , LQUERY , LREQ , LSAME , LSAVE , LWORK , M , M_ , MB_ , MID , MYCOL , MYROW , N , N_ , NALPHA , NB_ , NBETA , NCMP , NEIGINT , NEXT , NGL , NGLOB , NGU , NINT , NPCOL , NPROW , NSPLIT , OFFSET , ONE , ONEDCONTEXT , ORDER , P , PIVMIN , PREV , PSLAMCH , RANGE , RELFAC , RELTOL , REXTRA , RREQ , RSRC_ , SAFEMN , SELF , TMP1 , TMP2 , TNORM , TORECV , TWO , ULP , VL , VU , W , WORK , ZERO |
|
| Accessed arrays [ array name : associated index ] |
| |  BLACS_PNUM | : ICTXT, I, J |
| | D | : 1 , 1 , I , I , I , I , I+1 , IBEGIN , IBEGIN , IEND , IEND , J , J , N , N , N |
| | E | : I , I , J |
| | IBLOCK | : I , I , I , IWORK( INDRIW2+J ) , IWORK( J ) , J |
| | IDUM | : 1, 1 , 1, 2 , 2, 1 , 2, 2 , 3, 1 , 3, 2 , 4, 1 , 4, 1 , 4, 2 , 4, 2 , 5, 1 , 5, 1 , 5, 2 , 5, 2 , 5, 2 |
| | ISPLIT | : JB , NSPLIT , NSPLIT |
| | IWORK | : 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2*I , 2*I-1 , 2*M-I+1 , 2*M-I+1 , 2*M-I+1 , 3 , 4 , 5 , 5 , 5 , 5 , 5 , 6 , 6 , I , I , I , I , INDRIW1+1 , INDRIW1+IM+1 , INDRIW1+IM+1 , INDRIW1+IM+1 , INDRIW1+J , INDRIW2+1 , INDRIW2+IM+1 , INDRIW2+IM+1 , INDRIW2+IM+1 , INDRIW2+J , INDRIW2+J , ITMP1 , IWORK( 2*M-I+1 ) , IWORK( M+I ) , IWORK( M+I ) , IWORK( M+ITMP1 ) , IWORK( M+ITMP1 ) , J , J , K , M+1 , M+I , M+I , M+I , M+I , M+I , M+I , M+ITMP1 , M+ITMP1 , M+ITMP1 , M+ITMP1 , M+ITMP1 , M+ITMP1 , N+1 , N+J |
| | LSAME | : ORDER, 'A' , ORDER, 'B' , ORDER, 'E' , RANGE, 'A' , RANGE, 'I' , RANGE, 'V' |
| | PSLAMCH | : ICTXT, 'P' , ICTXT, 'S' |
| | W | : I , IWORK( INDRIW2+J ) , IWORK( J ) , J |
| | WORK | : 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2*I , 2*I-1 , 3 , 3 , 3 , 3 , 4 , I , I , I , INDRW1+1 , INDRW1+1 , INDRW1+1 , INDRW1+1 , INDRW1+1 , INDRW1+2*IOFF+1 , INDRW1+2*IOFF+1 , INDRW1+2*IOFF+1 , INDRW1+2*IOFF+1 , INDRW1+2*IOFF+1 , INDRW1+2*IOFF+1 , INDRW1+2*IOFF+1 , INDRW1+2*N , INDRW1+2*N-1 , INDRW1+J , INDRW1+J , INDRW1+J-1 , INDRW2+1 , INDRW2+IM+1 , INDRW2+IM+1 , INDRW2+IM+1 , INDRW2+J , ITMP1 , ITMP1 , ITMP1 , ITMP1 , ITMP1 , ITMP1 , IWORK( I ) , J , J , J , M-I+1 , M-I+1 |
|
| Conditional statements [ statement : associated predicate ] |
| | do | : ( 20 I = 0 , NPROW - 1 ) , ( 10 J = 0 , NPCOL - 1 ) , ( 30 I = 1 , N - 1 ) , ( 40 I = 1 , N - 1 ) , ( 90 JB = 1 , NSPLIT ) , ( 50 J = IBEGIN , IEND - 1 ) , ( a static partitioning of work so that each process ) , ( 60 J = OFFSET + NALPHA + 1 , OFFSET + NBETA ) , ( 80 I = 1 , IOUT ) , ( 70 J = OFFSET + IWORK( 2*I - 1 ) + 1 , ) , ( 130 I = 1 , P ) , ( 110 J = 1 , IM ) , ( 120 J = 1 , TORECV ) , ( 140 I = 1 , M ) , ( 150 I = 1 , M ) , ( 160 I = 1 , M ) , ( 170 I = 1 , M ) , ( 190 I = 1 , LEXTRA ) , ( 180 J = I + 1 , M ) , ( 210 I = 1 , REXTRA ) , ( 200 J = M - I , LEXTRA + 1 , - 1 ) , ( 220 I = 1 , M ) |
| | for | : ( Errors ) , ( entire matrix ) , ( split matrix ) , ( the current submatrix ) |
| | if | : ( BLOCK_CYCLIC_2D*CSRC_*CTXT_*DLEN_*DTYPE_*LLD_*MB_*M_*NB_*N_* ) , ( (LSAME( RANGE , 'A' ) ) ) , ( (LSAME( RANGE , 'V' ) ) ) , ( (LSAME( RANGE , 'I' ) ) ) , ( (LSAME( ORDER , 'B' ) ) ) , ( (LSAME( ORDER , 'E' ) .OR. LSAME( ORDER , 'A' ) ) ) , ( NPROW.EQ. - 1 ) , ( IRANGE.EQ.3 ) , ( MYROW.EQ.0 .AND. MYCOL.EQ.0 ) , ( IRANGE.EQ.2 ) , ( INFO.EQ.0 ) , ( IRANGE.EQ.0 ) , ( IORDER.EQ.0 ) , ( IRANGE.EQ.2 .AND. VL.GE.VU ) , ( (IRANGE.EQ.3 .AND. ( IL.LT.1 .OR. IL.GT.MAX( 1 , ) , ( (IRANGE.EQ.3 .AND. ( IU.LT.MIN( N , ) , ( (LWORK.LT.MAX( 5*N , 7 ) .AND. .NOT.LQUERY ) ) , ( (LIWORK.LT.MAX( 4*N , 14 , NPROW*NPCOL ) .AND. .NOT. ) , ( (IRANGE.EQ.2 .AND. ( ABS( WORK( 2 ) - VL ).GT.FIVE* ) , ( (IRANGE.EQ.2 .AND. ( ABS( WORK( 3 ) - VU ).GT.FIVE* ) , ( (ABS( WORK( 1 ) - ABSTOL ).GT.FIVE*ULP*ABS( ABSTOL ) ) ) , ( INFO.EQ.0 ) , ( INFO.EQ.BIGNUM ) , ( (MOD( INFO , DESCMULT ).EQ.0 ) ) , ( INFO.NE.0 ) , ( LWORK.EQ. - 1 .AND. LIWORK.EQ. - 1 ) , ( possible ) , ( N.EQ.0 ) , ( IRANGE.EQ.3 .AND. IL.EQ.1 .AND. IU.EQ.N ) , ( (ABS( D( I + 1 )*D( I ) )*ULP**2 + SAFEMN.GT.TMP1 ) ) , ( ABSTOL.LE.ZERO ) , ( on an IEEE machine , the sign bit is the ) , ( IRANGE.EQ.1 .OR. NSPLIT.EQ.1 ) , ( IRANGE.EQ.1 ) , ( IRANGE.EQ.2 ) , ( VL.GT.GL ) , ( IEFLAG.EQ.0 ) , ( VU.LT.GU ) , ( IEFLAG.EQ.0 ) , ( IRANGE.EQ.3 ) , ( IINFO.NE.0 ) , ( NINT.GT.1 ) , ( (IWORK( 5 ).EQ.IL - 1 ) ) , ( (IWORK( 1 ).LT.0 .OR. IWORK( 1 ).GT.IL - 1 .OR. ) , ( IFRST.GT.ILAST ) , ( IFRST.EQ.1 .AND. ILAST.EQ.N ) , ( JB.NE.1 ) , ( IRANGE.NE.1 ) , ( SELF.GE.P ) , ( IN.NE.N ) , ( ABSTOL.LE.ZERO ) , ( GL.LT.INITVL ) , ( IEFLAG.EQ.0 ) , ( GU.GT.INITVU ) , ( IEFLAG.EQ.0 ) , ( NGL.GE.NGU ) , ( ITMP1.LT.0 ) , ( ITMP1.LT.IREM ) , ( IMYLOAD.EQ.0 ) , ( IN.EQ.1 ) , ( ITMP2.LT.0 ) , ( ITMP2.LT.IREM ) , ( NBETA.GT.RREQ + INXTLOAD ) , ( LAST.LT.0 ) , ( SELF.NE.LAST ) , ( (SELF.NE.MOD( FOUND , P ) ) ) , ( (BETA-ALPHA.LE.MAX( ATOLI , RELTOL*MAX( ABS( ALPHA ) , ) , ( NEIGINT.LE.0 ) , ( IINFO.NE.0 ) , ( I.GT.IOUT - IINFO ) , ( SELF.EQ.I - 1 ) , ( IM.NE.0 ) , ( TORECV.NE.0 ) , ( NSPLIT.GT.1 .AND. IORDER.EQ.1 ) , ( (IRANGE.EQ.3 .AND. ( LEXTRA.GT.0 .OR. REXTRA.GT.0 ) ) ) , ( (WORK( J ).LT.WORK( ITMP1 ) ) ) , ( (WORK( J ).GT.WORK( ITMP1 ) ) ) , ( (IWORK( I ).GT.LEXTRA .AND. IWORK( I ).LE.M - REXTRA ) ) , ( M.NE.ILAST - IFRST + 1 ) |
|
| List of variables |
ABSTOL
ALPHA
ATOLI
BETA
BIGNUM
BLACS_PNUM
BLKNO
| BLOCK_CYCLIC_2D
BNORM
CSRC_
CTXT_
DESCMULT
DLEN_
DRECV
DSEND
| DTYPE_
FIVE
FOUND
FUDGE
GL
GU
HALF
I
| IBEGIN
IBLOCK
ICTXT
IDUM( 5, 2 )
IEFLAG
IEND
IFRST
IINFO
| IL
ILAST
ILOAD
IM
IMYLOAD
IN
INDRIW1
INDRIW2
| INDRW1
INDRW2
INFO
INITVL
INITVU
INXTLOAD
IOFF
IORDER
| IOUT
IRANGE
IRECV
IREM
ISPLIT
ITMP1
ITMP2
IU
| IWORK
J
JB
K
LAST
LEXTRA
LIWORK
LLD_
| LQUERY
LREQ
LSAME
LSAVE
LWORK
M
M_
MB_
| MID
MYCOL
MYROW
N
N_
NALPHA
NB_
NBETA
| NCMP
NEIGINT
NEXT
NGL
NGLOB
NGU
NINT
NPCOL
| NPROW
NSPLIT
OFFSET
ONE
ONEDCONTEXT
ORDER
P
PIVMIN
| PREV
PSLAMCH
RANGE
RELFAC
RELTOL
REXTRA
RREQ
RSRC_
| SAFEMN
SELF
TMP1
TMP2
TNORM
TORECV
TWO
ULP
| VL
VU
W
WORK
ZERO | | close
| |
ABSTOL
ALPHA
ATOLI
BETA
BIGNUM
BLACS_PNUM
BLKNO
BLOCK_CYCLIC_2D
BNORM
CSRC_
CTXT_
DESCMULT
DLEN_
DRECV
DSEND
DTYPE_
FIVE
FOUND
FUDGE
GL
GU
HALF
I
IBEGIN
IBLOCK
ICTXT
IDUM( 5, 2 )
IEFLAG
IEND
IFRST
IINFO
IL
ILAST
ILOAD
IM
IMYLOAD
IN
INDRIW1
INDRIW2
INDRW1
INDRW2
INFO
INITVL
INITVU
INXTLOAD
IOFF
IORDER
IOUT
IRANGE
IRECV
IREM
ISPLIT
ITMP1
ITMP2
IU
IWORK
J
JB
K
LAST
LEXTRA
LIWORK
LLD_
LQUERY
LREQ
LSAME
LSAVE
LWORK
M
M_
MB_
MID
MYCOL
MYROW
N
N_
NALPHA
NB_
NBETA
NCMP
NEIGINT
NEXT
NGL
NGLOB
NGU
NINT
NPCOL
NPROW
NSPLIT
OFFSET
ONE
ONEDCONTEXT
ORDER
P
PIVMIN
PREV
PSLAMCH
RANGE
RELFAC
RELTOL
REXTRA
RREQ
RSRC_
SAFEMN
SELF
TMP1
TMP2
TNORM
TORECV
TWO
ULP
VL
VU
W
WORK
ZERO
369#609#375#359
| |
