|
|
| |
| # lines: |
882 | | # code: |
882 | | # comment: | 0 | |
# blank: | 0 |
| # Variables: | 116 |
| # Callers: | 2 |
| # Callings: | 4 |
| # Words: | 663 |
| # Keywords: | 417 |
|
|
|
|
|
..
.. Array Arguments ..
..
Purpose
=======
PDSTEBZ 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 PDSTEBZ 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 single precision floating
point number is assumed be in the 32nd 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) DOUBLE PRECISION
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) DOUBLE PRECISION
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) DOUBLE PRECISION
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 DLAMCH('U'), not zero.
Note : If eigenvectors are desired later by inverse iteration
( PDSTEIN ), ABSTOL should be set to 2*PDLAMCH('S').
D (global input) DOUBLE PRECISION 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) DOUBLE PRECISION 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) DOUBLE PRECISION 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) DOUBLE PRECISION 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 PDLAMCH 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 DOUBLE PRECISION, 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 DOUBLE PRECISION, 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 PDSTEBZ( 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 DOUBLE PRECISION ABSTOL , VL , VU
015 INTRINSIC ABS , DBLE , ICHAR , MAX , MIN , MOD
016 * ..
017 * .. External Functions ..
018 LOGICAL LSAME
019 INTEGER BLACS_PNUM
020 DOUBLE PRECISION PDLAMCH
021 EXTERNAL LSAME , BLACS_PNUM , PDLAMCH
022 * ..
023 * .. External Subroutines ..
024 EXTERNAL BLACS_FREEBUFF , BLACS_GET , BLACS_GRIDEXIT ,
025 $BLACS_GRIDINFO , BLACS_GRIDMAP , DGEBR2D ,
026 $DGEBS2D , DGERV2D , DGESD2D , DLASRT2 , GLOBCHK ,
027 $IGEBR2D , IGEBS2D , IGERV2D , IGESD2D , IGSUM2D ,
028 $PDLAEBZ , PDLAIECTB , PDLAIECTL , PDLAPDCT ,
029 $PDLASNBT , PXERBLA
030 * ..
031 * .. Parameters ..
032 INTEGER BLOCK_CYCLIC_2D , DLEN_ , DTYPE_ , CTXT_ , M_ , N_ ,
033 $MB_ , NB_ , RSRC_ , CSRC_ , LLD_
034 PARAMETER( BLOCK_CYCLIC_2D = 1 , DLEN_ = 9 , DTYPE_ = 1 ,
035 $CTXT_ = 2 , M_ = 3 , N_ = 4 , MB_ = 5 , NB_ = 6 ,
036 $RSRC_ = 7 , CSRC_ = 8 , LLD_ = 9 )
037 INTEGER BIGNUM , DESCMULT
038 PARAMETER( BIGNUM = 10000 , DESCMULT = 100 )
039 DOUBLE PRECISION ZERO , ONE , TWO , FIVE , HALF
040 PARAMETER( ZERO = 0.0D + 0 , ONE = 1.0D + 0 , TWO = 2.0D + 0 ,
041 $FIVE = 5.0D + 0 , HALF = 1.0D + 0 / TWO )
042 DOUBLE PRECISION FUDGE , RELFAC
043 PARAMETER( FUDGE = 2.0D + 0 , RELFAC = 2.0D + 0 )
044 * ..
045 * .. Local Scalars ..
046 LOGICAL LQUERY
047 INTEGER BLKNO , FOUND , I , IBEGIN , IEFLAG , IEND , IFRST ,
048 $IINFO , ILAST , ILOAD , IM , IMYLOAD , IN , INDRIW1 ,
049 $INDRIW2 , INDRW1 , INDRW2 , INXTLOAD , IOFF ,
050 $IORDER , IOUT , IRANGE , IRECV , IREM , ITMP1 ,
051 $ITMP2 , J , JB , K , LAST , LEXTRA , LREQ , MYCOL ,
052 $MYROW , NALPHA , NBETA , NCMP , NEIGINT , NEXT , NGL ,
053 $NGLOB , NGU , NINT , NPCOL , NPROW , OFFSET ,
054 $ONEDCONTEXT , P , PREV , REXTRA , RREQ , SELF ,
055 $TORECV
056 DOUBLE PRECISION ALPHA , ATOLI , BETA , BNORM , DRECV , DSEND , GL ,
057 $GU , INITVL , INITVU , LSAVE , MID , PIVMIN , RELTOL ,
058 $SAFEMN , TMP1 , TMP2 , TNORM , ULP
059 * ..
060 * .. Local Arrays ..
061 INTEGER IDUM( 5 , 2 )
062 * ..
063 * .. Executable Statements ..
064 * This is just to keep ftnchek happy
065 IF( BLOCK_CYCLIC_2D*CSRC_*CTXT_*DLEN_*DTYPE_*LLD_*MB_*M_*NB_*N_*
065  
066 $ RSRC_.LT.0 )RETURN
067
068 * Set up process grid
069
070 CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
071
072 INFO = 0
073 M = 0
074
075 * Decode RANGE
076
077 IF( LSAME( RANGE , 'A' ) ) THEN
077
078 IRANGE = 1
079 ELSE IF( LSAME( RANGE , 'V' ) ) THEN
079
080 IRANGE = 2
081 ELSE IF( LSAME( RANGE , 'I' ) ) THEN
081
082 IRANGE = 3
083 ELSE
083
084 IRANGE = 0
085 END IF
086
087 * Decode ORDER
088
089 IF( LSAME( ORDER , 'B' ) ) THEN
089
090 IORDER = 2
091 ELSE IF( LSAME( ORDER , 'E' ) .OR. LSAME( ORDER , 'A' ) ) THEN
091
092 IORDER = 1
093 ELSE
093
094 IORDER = 0
095 END IF
096
097 * Check for Errors
098
099 IF( NPROW.EQ. - 1 ) THEN
099
100 INFO = - 1
101 ELSE
102
103 * Get machine constants
104
104
105 SAFEMN = PDLAMCH( ICTXT , 'S' )
106 ULP = PDLAMCH( ICTXT , 'P' )
107 RELTOL = ULP*RELFAC
108 IDUM( 1 , 1 ) = ICHAR( RANGE )
109 IDUM( 1 , 2 ) = 2
110 IDUM( 2 , 1 ) = ICHAR( ORDER )
111 IDUM( 2 , 2 ) = 3
112 IDUM( 3 , 1 ) = N
113 IDUM( 3 , 2 ) = 4
114 NGLOB = 5
115 IF( IRANGE.EQ.3 ) THEN
115
116 IDUM( 4 , 1 ) = IL
117 IDUM( 4 , 2 ) = 7
118 IDUM( 5 , 1 ) = IU
119 IDUM( 5 , 2 ) = 8
120 ELSE
120
121 IDUM( 4 , 1 ) = 0
122 IDUM( 4 , 2 ) = 0
123 IDUM( 5 , 1 ) = 0
124 IDUM( 5 , 2 ) = 0
125 END IF
126 IF( MYROW.EQ.0 .AND. MYCOL.EQ.0 ) THEN
126
127 WORK( 1 ) = ABSTOL
128 IF( IRANGE.EQ.2 ) THEN
128
129 WORK( 2 ) = VL
130 WORK( 3 ) = VU
131 ELSE
131
132 WORK( 2 ) = ZERO
133 WORK( 3 ) = ZERO
134 END IF
135 CALL DGEBS2D( ICTXT , 'ALL' , ' ' , 3 , 1 , WORK , 3 )
136 ELSE
136
137 CALL DGEBR2D( ICTXT , 'ALL' , ' ' , 3 , 1 , WORK , 3 , 0 , 0 )
138 END IF
139 LQUERY =( LWORK.EQ. - 1 .OR. LIWORK.EQ. - 1 )
140 IF( INFO.EQ.0 ) THEN
140
141 IF( IRANGE.EQ.0 ) THEN
141
142 INFO = - 2
143 ELSE IF( IORDER.EQ.0 ) THEN
143
144 INFO = - 3
145 ELSE IF( IRANGE.EQ.2 .AND. VL.GE.VU ) THEN
145
146 INFO = - 5
147 ELSE IF( IRANGE.EQ.3 .AND.( IL.LT.1 .OR. IL.GT.MAX( 1 ,
147
148 $ N ) ) ) THEN
149 INFO = - 6
150 ELSE IF( IRANGE.EQ.3 .AND.( IU.LT.MIN( N ,
150
151 $ IL ) .OR. IU.GT.N ) ) THEN
152 INFO = - 7
153 ELSE IF( LWORK.LT.MAX( 5*N , 7 ) .AND. .NOT.LQUERY ) THEN
153
154 INFO = - 18
155 ELSE IF( LIWORK.LT.MAX( 4*N , 14 , NPROW*NPCOL ) .AND. .NOT.
155
156 $ LQUERY ) THEN
157 INFO = - 20
158 ELSE IF( IRANGE.EQ.2 .AND.( ABS( WORK( 2 ) - VL ).GT.FIVE*
158
159 $ ULP*ABS( VL ) ) ) THEN
160 INFO = - 5
161 ELSE IF( IRANGE.EQ.2 .AND.( ABS( WORK( 3 ) - VU ).GT.FIVE*
161
162 $ ULP*ABS( VU ) ) ) THEN
163 INFO = - 6
164 ELSE IF( ABS( WORK( 1 ) - ABSTOL ).GT.FIVE*ULP*ABS( ABSTOL ) )
164
165 $ THEN
166 INFO = - 9
167 END IF
168 END IF
169 IF( INFO.EQ.0 )
169
170 $ INFO = BIGNUM
171 CALL GLOBCHK( ICTXT , NGLOB , IDUM , 5 , IWORK , INFO )
172 IF( INFO.EQ.BIGNUM ) THEN
172
173 INFO = 0
174 ELSE IF( MOD( INFO , DESCMULT ).EQ.0 ) THEN
174
175 INFO = - INFO / DESCMULT
176 ELSE
176
177 INFO = - INFO
178 END IF
179 END IF
180 WORK( 1 ) = DBLE( MAX( 5*N , 7 ) )
181 IWORK( 1 ) = MAX( 4*N , 14 , NPROW*NPCOL )
182
183 IF( INFO.NE.0 ) THEN
183
184 CALL PXERBLA( ICTXT , 'PDSTEBZ' , - INFO )
185 RETURN
186 ELSE IF( LWORK.EQ. - 1 .AND. LIWORK.EQ. - 1 ) THEN
186
187 RETURN
188 END IF
189
190 * Quick return if possible
191
192 IF( N.EQ.0 )
192
193 $ RETURN
194
195 K = 1
196 DO 20 I = 0 , NPROW - 1
196
197 DO 10 J = 0 , NPCOL - 1
197
198 IWORK( K ) = BLACS_PNUM( ICTXT , I , J )
199 K = K + 1
200 10 CONTINUE
201 20 CONTINUE
202
202
203 P = NPROW*NPCOL
204 NPROW = 1
205 NPCOL = P
206
207 CALL BLACS_GET( ICTXT , 10 , ONEDCONTEXT )
208 CALL BLACS_GRIDMAP( ONEDCONTEXT , IWORK , NPROW , NPROW , NPCOL )
209 CALL BLACS_GRIDINFO( ONEDCONTEXT , I , J , K , SELF )
210
211 * Simplifications :
212
213 IF( IRANGE.EQ.3 .AND. IL.EQ.1 .AND. IU.EQ.N )
213
214 $ IRANGE = 1
215
216 NEXT = MOD( SELF + 1 , P )
217 PREV = MOD( P + SELF - 1 , P )
218
219 * Compute squares of off - diagonals , splitting points and pivmin.
220 * Interleave diagonals and off - diagonals.
221
222 INDRW1 = MAX( 2*N , 4 )
223 INDRW2 = INDRW1 + 2*N
224 INDRIW1 = MAX( 2*N , 8 )
225 NSPLIT = 1
226 WORK( INDRW1 + 2*N ) = ZERO
227 PIVMIN = ONE
228
229 DO 30 I = 1 , N - 1
229
230 TMP1 = E( I )**2
231 J = 2*I
232 WORK( INDRW1 + J - 1 ) = D( I )
233 IF( ABS( D( I + 1 )*D( I ) )*ULP**2 + SAFEMN.GT.TMP1 ) THEN
233
234 ISPLIT( NSPLIT ) = I
235 NSPLIT = NSPLIT + 1
236 WORK( INDRW1 + J ) = ZERO
237 ELSE
237
238 WORK( INDRW1 + J ) = TMP1
239 PIVMIN = MAX( PIVMIN , TMP1 )
240 END IF
241 30 CONTINUE
241
242 WORK( INDRW1 + 2*N - 1 ) = D( N )
243 ISPLIT( NSPLIT ) = N
244 PIVMIN = PIVMIN*SAFEMN
245
246 * Compute Gershgorin interval[gl , gu] for entire matrix
247
248 GU = D( 1 )
249 GL = D( 1 )
250 TMP1 = ZERO
251
252 DO 40 I = 1 , N - 1
252
253 TMP2 = ABS( E( I ) )
254 GU = MAX( GU , D( I ) + TMP1 + TMP2 )
255 GL = MIN( GL , D( I ) - TMP1 - TMP2 )
256 TMP1 = TMP2
257 40 CONTINUE
257
258 GU = MAX( GU , D( N ) + TMP1 )
259 GL = MIN( GL , D( N ) - TMP1 )
260 TNORM = MAX( ABS( GL ) , ABS( GU ) )
261 GL = GL - FUDGE*TNORM*ULP*N - FUDGE*TWO*PIVMIN
262 GU = GU + FUDGE*TNORM*ULP*N + FUDGE*PIVMIN
263
264 IF( ABSTOL.LE.ZERO ) THEN
264
265 ATOLI = ULP*TNORM
266 ELSE
266
267 ATOLI = ABSTOL
268 END IF
269
270 * Find out if on an IEEE machine , the sign bit is the
271 * 32nd bit(Big Endian) or the 64th bit(Little Endian)
272
273 IF( IRANGE.EQ.1 .OR. NSPLIT.EQ.1 ) THEN
273
274 CALL PDLASNBT( IEFLAG )
275 ELSE
275
276 IEFLAG = 0
277 END IF
278 LEXTRA = 0
279 REXTRA = 0
280
281 * Form Initial Interval containing desired eigenvalues
282
283 IF( IRANGE.EQ.1 ) THEN
283
284 INITVL = GL
285 INITVU = GU
286 WORK( 1 ) = GL
287 WORK( 2 ) = GU
288 IWORK( 1 ) = 0
289 IWORK( 2 ) = N
290 IFRST = 1
291 ILAST = N
292 ELSE IF( IRANGE.EQ.2 ) THEN
292
293 IF( VL.GT.GL ) THEN
293
294 IF( IEFLAG.EQ.0 ) THEN
294
295 CALL PDLAPDCT ( VL , N , WORK( INDRW1 + 1 ) , PIVMIN , IFRST )
296 ELSE IF( IEFLAG.EQ.1 ) THEN
296
297 CALL PDLAIECTB( VL , N , WORK( INDRW1 + 1 ) , IFRST )
298 ELSE
298
299 CALL PDLAIECTL( VL , N , WORK( INDRW1 + 1 ) , IFRST )
300 END IF
301 IFRST = IFRST + 1
302 INITVL = VL
303 ELSE
303
304 INITVL = GL
305 IFRST = 1
306 END IF
307 IF( VU.LT.GU ) THEN
307
308 IF( IEFLAG.EQ.0 ) THEN
308
309 CALL PDLAPDCT ( VU , N , WORK( INDRW1 + 1 ) , PIVMIN , ILAST )
310 ELSE IF( IEFLAG.EQ.1 ) THEN
310
311 CALL PDLAIECTB( VU , N , WORK( INDRW1 + 1 ) , ILAST )
312 ELSE
312
313 CALL PDLAIECTL( VU , N , WORK( INDRW1 + 1 ) , ILAST )
314 END IF
315 INITVU = VU
316 ELSE
316
317 INITVU = GU
318 ILAST = N
319 END IF
320 WORK( 1 ) = INITVL
321 WORK( 2 ) = INITVU
322 IWORK( 1 ) = IFRST - 1
323 IWORK( 2 ) = ILAST
324 ELSE IF( IRANGE.EQ.3 ) THEN
324
325 WORK( 1 ) = GL
326 WORK( 2 ) = GU
327 IWORK( 1 ) = 0
328 IWORK( 2 ) = N
329 IWORK( 5 ) = IL - 1
330 IWORK( 6 ) = IU
331 CALL PDLAEBZ ( 0 , N , 2 , 1 , ATOLI , RELTOL , PIVMIN ,
332 $ WORK( INDRW1 + 1 ) , IWORK( 5 ) , WORK , IWORK , NINT ,
333 $ LSAVE , IEFLAG , IINFO )
334 IF( IINFO.NE.0 ) THEN
334
335 INFO = 3
336 GO TO 230
337 END IF
338 IF( NINT.GT.1 ) THEN
338
339 IF( IWORK( 5 ).EQ.IL - 1 ) THEN
339
340 WORK( 2 ) = WORK( 4 )
341 IWORK( 2 ) = IWORK( 4 )
342 ELSE
342
343 WORK( 1 ) = WORK( 3 )
344 IWORK( 1 ) = IWORK( 3 )
345 END IF
346 IF( IWORK( 1 ).LT.0 .OR. IWORK( 1 ).GT.IL - 1 .OR.
347 $ IWORK( 2 ).LE.MIN( IU - 1 , IWORK( 1 ) ) .OR.
348 $ IWORK( 2 ).GT.N ) THEN
349 INFO = 3
350 GO TO 230
351 END IF
352 END IF
353 LEXTRA = IL - 1 - IWORK( 1 )
354 REXTRA = IWORK( 2 ) - IU
355 INITVL = WORK( 1 )
356 INITVU = WORK( 2 )
357 IFRST = IL
358 ILAST = IU
359 END IF
360 * NVL = IFRST - 1
361 * NVU = ILAST
362 GL = INITVL
363 GU = INITVU
364 NGL = IWORK( 1 )
365 NGU = IWORK( 2 )
366 IM = 0
367 FOUND = 0
368 INDRIW2 = INDRIW1 + NGU - NGL
369 IEND = 0
370 IF( IFRST.GT.ILAST )
370
371 $ GO TO 100
372 IF( IFRST.EQ.1 .AND. ILAST.EQ.N )
372
373 $ IRANGE = 1
374
375 * Find Eigenvalues -- Loop Over Blocks
376
377 DO 90 JB = 1 , NSPLIT
377
378 IOFF = IEND
379 IBEGIN = IOFF + 1
380 IEND = ISPLIT( JB )
381 IN = IEND - IOFF
382 IF( JB.NE.1 ) THEN
382
383 IF( IRANGE.NE.1 ) THEN
383
384 FOUND = IM
385
386 * Find total number of eigenvalues found thus far
387
388 CALL IGSUM2D( ONEDCONTEXT , 'All' , ' ' , 1 , 1 , FOUND , 1 ,
389 $ - 1 , - 1 )
390 ELSE
390
391 FOUND = IOFF
392 END IF
393 END IF
394 * IF( SELF.GE.P )
395 * $ GO TO 30
396 IF( IN.NE.N ) THEN
397
398 * Compute Gershgorin interval[gl , gu] for split matrix
399
399
400 GU = D( IBEGIN )
401 GL = D( IBEGIN )
402 TMP1 = ZERO
403
404 DO 50 J = IBEGIN , IEND - 1
404
405 TMP2 = ABS( E( J ) )
406 GU = MAX( GU , D( J ) + TMP1 + TMP2 )
407 GL = MIN( GL , D( J ) - TMP1 - TMP2 )
408 TMP1 = TMP2
409 50 CONTINUE
410
410
411 GU = MAX( GU , D( IEND ) + TMP1 )
412 GL = MIN( GL , D( IEND ) - TMP1 )
413 BNORM = MAX( ABS( GL ) , ABS( GU ) )
414 GL = GL - FUDGE*BNORM*ULP*IN - FUDGE*PIVMIN
415 GU = GU + FUDGE*BNORM*ULP*IN + FUDGE*PIVMIN
416
417 * Compute ATOLI for the current submatrix
418
419 IF( ABSTOL.LE.ZERO ) THEN
419
420 ATOLI = ULP*BNORM
421 ELSE
421
422 ATOLI = ABSTOL
423 END IF
424
425 IF( GL.LT.INITVL ) THEN
425
426 GL = INITVL
427 IF( IEFLAG.EQ.0 ) THEN
427
428 CALL PDLAPDCT ( GL , IN , WORK( INDRW1 + 2*IOFF + 1 ) ,
429 $ PIVMIN , NGL )
430 ELSE IF( IEFLAG.EQ.1 ) THEN
430
431 CALL PDLAIECTB( GL , IN , WORK( INDRW1 + 2*IOFF + 1 ) , NGL )
432 ELSE
432
433 CALL PDLAIECTL( GL , IN , WORK( INDRW1 + 2*IOFF + 1 ) , NGL )
434 END IF
435 ELSE
435
436 NGL = 0
437 END IF
438 IF( GU.GT.INITVU ) THEN
438
439 GU = INITVU
440 IF( IEFLAG.EQ.0 ) THEN
440
441 CALL PDLAPDCT ( GU , IN , WORK( INDRW1 + 2*IOFF + 1 ) ,
442 $ PIVMIN , NGU )
443 ELSE IF( IEFLAG.EQ.1 ) THEN
443
444 CALL PDLAIECTB( GU , IN , WORK( INDRW1 + 2*IOFF + 1 ) , NGU )
445 ELSE
445
446 CALL PDLAIECTL( GU , IN , WORK( INDRW1 + 2*IOFF + 1 ) , NGU )
447 END IF
448 ELSE
448
449 NGU = IN
450 END IF
451 IF( NGL.GE.NGU )
451
452 $ GO TO 90
453 WORK( 1 ) = GL
454 WORK( 2 ) = GU
455 IWORK( 1 ) = NGL
456 IWORK( 2 ) = NGU
457 END IF
458 OFFSET = FOUND - NGL
459 BLKNO = JB
460
461 * Do a static partitioning of work so that each process
462 * has to find an(almost) equal number of eigenvalues
463
464 NCMP = NGU - NGL
465 ILOAD = NCMP / P
466 IREM = NCMP - ILOAD*P
467 ITMP1 = MOD( SELF - FOUND , P )
468 IF( ITMP1.LT.0 )
468
469 $ ITMP1 = ITMP1 + P
470 IF( ITMP1.LT.IREM ) THEN
470
471 IMYLOAD = ILOAD + 1
472 ELSE
472
473 IMYLOAD = ILOAD
474 END IF
475 IF( IMYLOAD.EQ.0 ) THEN
475
476 GO TO 90
477 ELSE IF( IN.EQ.1 ) THEN
477
478 WORK( INDRW2 + IM + 1 ) = WORK( INDRW1 + 2*IOFF + 1 )
479 IWORK( INDRIW1 + IM + 1 ) = BLKNO
480 IWORK( INDRIW2 + IM + 1 ) = OFFSET + 1
481 IM = IM + 1
482 GO TO 90
483 ELSE
483
484 INXTLOAD = ILOAD
485 ITMP2 = MOD( SELF + 1 - FOUND , P )
486 IF( ITMP2.LT.0 )
486
487 $ ITMP2 = ITMP2 + P
488 IF( ITMP2.LT.IREM )
488
489 $ INXTLOAD = INXTLOAD + 1
490 LREQ = NGL + ITMP1*ILOAD + MIN( IREM , ITMP1 )
491 RREQ = LREQ + IMYLOAD
492 IWORK( 5 ) = LREQ
493 IWORK( 6 ) = RREQ
494 TMP1 = WORK( 1 )
495 ITMP1 = IWORK( 1 )
496 CALL PDLAEBZ ( 1 , IN , 1 , 1 , ATOLI , RELTOL , PIVMIN ,
497 $ WORK( INDRW1 + 2*IOFF + 1 ) , IWORK( 5 ) , WORK ,
498 $ IWORK , NINT , LSAVE , IEFLAG , IINFO )
499 ALPHA = WORK( 1 )
500 BETA = WORK( 2 )
501 NALPHA = IWORK( 1 )
502 NBETA = IWORK( 2 )
503 DSEND = BETA
504 IF( NBETA.GT.RREQ + INXTLOAD ) THEN
504
505 NBETA = RREQ
506 DSEND = ALPHA
507 END IF
508 LAST = MOD( FOUND + MIN( NGU - NGL , P ) - 1 , P )
509 IF( LAST.LT.0 )
509
510 $ LAST = LAST + P
511 IF( SELF.NE.LAST ) THEN
511
512 CALL DGESD2D( ONEDCONTEXT , 1 , 1 , DSEND , 1 , 0 , NEXT )
513 CALL IGESD2D( ONEDCONTEXT , 1 , 1 , NBETA , 1 , 0 , NEXT )
514 END IF
515 IF( SELF.NE.MOD( FOUND , P ) ) THEN
515
516 CALL DGERV2D( ONEDCONTEXT , 1 , 1 , DRECV , 1 , 0 , PREV )
517 CALL IGERV2D( ONEDCONTEXT , 1 , 1 , IRECV , 1 , 0 , PREV )
518 ELSE
518
519 DRECV = TMP1
520 IRECV = ITMP1
521 END IF
522 WORK( 1 ) = MAX( LSAVE , DRECV )
523 IWORK( 1 ) = IRECV
524 ALPHA = MAX( ALPHA , WORK( 1 ) )
525 NALPHA = MAX( NALPHA , IRECV )
526 IF( BETA - ALPHA.LE.MAX( ATOLI , RELTOL*MAX( ABS( ALPHA ) ,
527 $ ABS( BETA ) ) ) ) THEN
528 MID = HALF*( ALPHA + BETA )
529 DO 60 J = OFFSET + NALPHA + 1 , OFFSET + NBETA
530 WORK( INDRW2 + IM + 1 ) = MID
531 IWORK( INDRIW1 + IM + 1 ) = BLKNO
532 IWORK( INDRIW2 + IM + 1 ) = J
533 IM = IM + 1
534 60 CONTINUE
534
535 WORK( 2 ) = ALPHA
536 IWORK( 2 ) = NALPHA
537 END IF
538 END IF
539 NEIGINT = IWORK( 2 ) - IWORK( 1 )
540 IF( NEIGINT.LE.0 )
540
541 $ GO TO 90
542
543 * Call the main computational routine
544
545 CALL PDLAEBZ ( 2 , IN , NEIGINT , 1 , ATOLI , RELTOL , PIVMIN ,
546 $ WORK( INDRW1 + 2*IOFF + 1 ) , IWORK , WORK , IWORK ,
547 $ IOUT , LSAVE , IEFLAG , IINFO )
548 IF( IINFO.NE.0 ) THEN
548
549 INFO = 1
550 END IF
551 DO 80 I = 1 , IOUT
551
552 MID = HALF*( WORK( 2*I - 1 ) + WORK( 2*I ) )
553 IF( I.GT.IOUT - IINFO )
553
554 $ BLKNO = - BLKNO
555 DO 70 J = OFFSET + IWORK( 2*I - 1 ) + 1 ,
556 $ OFFSET + IWORK( 2*I )
557 WORK( INDRW2 + IM + 1 ) = MID
558 IWORK( INDRIW1 + IM + 1 ) = BLKNO
559 IWORK( INDRIW2 + IM + 1 ) = J
560 IM = IM + 1
561 70 CONTINUE
562 80 CONTINUE
563 90 CONTINUE
564
565 * Find out total number of eigenvalues computed
566
567 100 CONTINUE
568 M = IM
569 CALL IGSUM2D( ONEDCONTEXT , 'ALL' , ' ' , 1 , 1 , M , 1 , - 1 , - 1 )
570
571 * Move the eigenvalues found to their final destinations
572
573 DO 130 I = 1 , P
573
574 IF( SELF.EQ.I - 1 ) THEN
574
575 CALL IGEBS2D( ONEDCONTEXT , 'ALL' , ' ' , 1 , 1 , IM , 1 )
576 IF( IM.NE.0 ) THEN
576
577 CALL IGEBS2D( ONEDCONTEXT , 'ALL' , ' ' , IM , 1 ,
578 $ IWORK( INDRIW2 + 1 ) , IM )
579 CALL DGEBS2D( ONEDCONTEXT , 'ALL' , ' ' , IM , 1 ,
580 $ WORK( INDRW2 + 1 ) , IM )
581 CALL IGEBS2D( ONEDCONTEXT , 'ALL' , ' ' , IM , 1 ,
582 $ IWORK( INDRIW1 + 1 ) , IM )
583 DO 110 J = 1 , IM
583
584 W( IWORK( INDRIW2 + J ) ) = WORK( INDRW2 + J )
585 IBLOCK( IWORK( INDRIW2 + J ) ) = IWORK( INDRIW1 + J )
586 110 CONTINUE
586
587 END IF
588 ELSE
588
589 CALL IGEBR2D( ONEDCONTEXT , 'ALL' , ' ' , 1 , 1 , TORECV , 1 , 0 ,
590 $ I - 1 )
591 IF( TORECV.NE.0 ) THEN
591
592 CALL IGEBR2D( ONEDCONTEXT , 'ALL' , ' ' , TORECV , 1 , IWORK ,
593 $ TORECV , 0 , I - 1 )
594 CALL DGEBR2D( ONEDCONTEXT , 'ALL' , ' ' , TORECV , 1 , WORK ,
595 $ TORECV , 0 , I - 1 )
596 CALL IGEBR2D( ONEDCONTEXT , 'ALL' , ' ' , TORECV , 1 ,
597 $ IWORK( N + 1 ) , TORECV , 0 , I - 1 )
598 DO 120 J = 1 , TORECV
598
599 W( IWORK( J ) ) = WORK( J )
600 IBLOCK( IWORK( J ) ) = IWORK( N + J )
601 120 CONTINUE
601
602 END IF
603 END IF
604 130 CONTINUE
605 IF( NSPLIT.GT.1 .AND. IORDER.EQ.1 ) THEN
606
607 * Sort the eigenvalues
608
608
609 DO 140 I = 1 , M
609
610 IWORK( M + I ) = I
611 140 CONTINUE
611
612 CALL DLASRT2 ( 'I' , M , W , IWORK( M + 1 ) , IINFO )
613 DO 150 I = 1 , M
613
614 IWORK( I ) = IBLOCK( I )
615 150 CONTINUE
615
616 DO 160 I = 1 , M
616
617 IBLOCK( I ) = IWORK( IWORK( M + I ) )
618 160 CONTINUE
619 END IF
620 IF( IRANGE.EQ.3 .AND.( LEXTRA.GT.0 .OR. REXTRA.GT.0 ) ) THEN
621
622 * Discard unwanted eigenvalues(occurs only when RANGE = 'I' ,
623 * and eigenvalues IL , and / or IU are in a cluster)
624
624
625 DO 170 I = 1 , M
625
626 WORK( I ) = W( I )
627 IWORK( I ) = I
628 IWORK( M + I ) = I
629 170 CONTINUE
629
630 DO 190 I = 1 , LEXTRA
630
631 ITMP1 = I
632 DO 180 J = I + 1 , M
632
633 IF( WORK( J ).LT.WORK( ITMP1 ) ) THEN
633
634 ITMP1 = J
635 END IF
636 180 CONTINUE
636
637 TMP1 = WORK( I )
638 WORK( I ) = WORK( ITMP1 )
639 WORK( ITMP1 ) = TMP1
640 IWORK( IWORK( M + ITMP1 ) ) = I
641 IWORK( IWORK( M + I ) ) = ITMP1
642 ITMP2 = IWORK( M + I )
643 IWORK( M + I ) = IWORK( M + ITMP1 )
644 IWORK( M + ITMP1 ) = ITMP2
645 190 CONTINUE
645
646 DO 210 I = 1 , REXTRA
646
647 ITMP1 = M - I + 1
648 DO 200 J = M - I , LEXTRA + 1 , - 1
648
649 IF( WORK( J ).GT.WORK( ITMP1 ) ) THEN
649
650 ITMP1 = J
651 END IF
652 200 CONTINUE
652
653 TMP1 = WORK( M - I + 1 )
654 WORK( M - I + 1 ) = WORK( ITMP1 )
655 WORK( ITMP1 ) = TMP1
656 IWORK( IWORK( M + ITMP1 ) ) = M - I + 1
657 IWORK( IWORK( 2*M - I + 1 ) ) = ITMP1
658 ITMP2 = IWORK( 2*M - I + 1 )
659 IWORK( 2*M - I + 1 ) = IWORK( M + ITMP1 )
660 IWORK( M + ITMP1 ) = ITMP2
661 * IWORK( ITMP1 ) = 1
662 210 CONTINUE
662
663 J = 0
664 DO 220 I = 1 , M
664
665 IF( IWORK( I ).GT.LEXTRA .AND. IWORK( I ).LE.M - REXTRA ) THEN
665
666 J = J + 1
667 W( J ) = WORK( IWORK( I ) )
668 IBLOCK( J ) = IBLOCK( I )
669 END IF
670 220 CONTINUE
670
671 M = M - LEXTRA - REXTRA
672 END IF
673 IF( M.NE.ILAST - IFRST + 1 ) THEN
673
674 INFO = 2
675 END IF
676
677 230 CONTINUE
678 CALL BLACS_FREEBUFF( ONEDCONTEXT , 1 )
679 CALL BLACS_GRIDEXIT( ONEDCONTEXT )
680 RETURN
681
682 * End of PDSTEBZ
683
684 END
685 59
137
|
|
Variables in Routine PDSTEBZ()
| Summary Report |
| Data Type | Quantity | Size(byte) |
| CHARACTER | 2 | 2 |
| DOUBLE PRECISION | 30 | 120 |
| INTEGER | 80 | 336 |
| LOGICAL | 2 | 2 |
| REAL | 2 | 8 |
| TOTAL | 116 | 468 |
List of Variables
CHARACTER
DOUBLE PRECISION
| ABSTOL | ALPHA | ATOLI | BETA | BNORM |
| DRECV | DSEND | FIVE | FUDGE | GL |
| GU | HALF | INITVL | INITVU | LSAVE |
| MID | ONE | PDLAMCH | PIVMIN | RELFAC |
| RELTOL | SAFEMN | TMP1 | TMP2 | TNORM |
| TWO | ULP | VL | VU | ZERO |
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
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 = PDLAMCH( ICTXT, 'S' ), PDLAMCHSAFEMN = PDLAMCH( 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 = PDLAMCH( ICTXT, 'P' ), PULP = PDLAMCH( ICTXT, 'P' ), PDLAMCHULP = PDLAMCH( 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 ) = DBLE( MAX( 5*N, 7 ) ){2WORK( INDRW1+2*N-1 ) = D( N )} |
|
|
Analysis elements of the routine PDSTEBZ()
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 , PDLAMCH , PIVMIN , PREV , 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' |
| | PDLAMCH | : 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+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*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 ) , ( IEFLAG.EQ.1 ) , ( VU.LT.GU ) , ( IEFLAG.EQ.0 ) , ( IEFLAG.EQ.1 ) , ( 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 ) , ( IEFLAG.EQ.1 ) , ( GU.GT.INITVU ) , ( IEFLAG.EQ.0 ) , ( IEFLAG.EQ.1 ) , ( 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
PDLAMCH
| PIVMIN
PREV
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
PDLAMCH
PIVMIN
PREV
RANGE
RELFAC
RELTOL
REXTRA
RREQ
RSRC_
SAFEMN
SELF
TMP1
TMP2
TNORM
TORECV
TWO
ULP
VL
VU
W
WORK
ZERO
219#225#209#21
| |
