|
|
| |
| # lines: |
453 | | # code: |
453 | | # comment: | 0 | |
# blank: | 0 |
| # Variables: | 72 |
| # Callers: | 1 |
| # Callings: | 2 |
| # Words: | 201 |
| # Keywords: | 135 |
|
|
|
|
|
..
.. Array Arguments ..
..
Purpose
=======
PSLAED2 sorts the two sets of eigenvalues together into a single
sorted set. Then it tries to deflate the size of the problem.
There are two ways in which deflation can occur: when two or more
eigenvalues are close together or if there is a tiny entry in the
Z vector. For each such occurrence the order of the related secular
equation problem is reduced by one.
Arguments
=========
ICTXT (global input) INTEGER
The BLACS context handle, indicating the global context of
the operation on the matrix. The context itself is global.
K (output) INTEGER
The number of non-deflated eigenvalues, and the order of the
related secular equation. 0 <= K <=N.
N (input) INTEGER
The dimension of the symmetric tridiagonal matrix. N >= 0.
N1 (input) INTEGER
The location of the last eigenvalue in the leading sub-matrix.
min(1,N) < N1 < N.
NB (global input) INTEGER
The blocking factor used to distribute the columns of the
matrix. NB >= 1.
D (input/output) REAL array, dimension (N)
On entry, D contains the eigenvalues of the two submatrices to
be combined.
On exit, D contains the trailing (N-K) updated eigenvalues
(those which were deflated) sorted into increasing order.
DROW (global input) INTEGER
The process row over which the first row of the matrix D is
distributed. 0 <= DROW < NPROW.
DCOL (global input) INTEGER
The process column over which the first column of the
matrix D is distributed. 0 <= DCOL < NPCOL.
Q (input/output) REAL array, dimension (LDQ, N)
On entry, Q contains the eigenvectors of two submatrices in
the two square blocks with corners at (1,1), (N1,N1)
and (N1+1, N1+1), (N,N).
On exit, Q contains the trailing (N-K) updated eigenvectors
(those which were deflated) in its last N-K columns.
LDQ (input) INTEGER
The leading dimension of the array Q. LDQ >= max(1,NQ).
RHO (global input/output) REAL
On entry, the off-diagonal element associated with the rank-1
cut which originally split the two submatrices which are now
being recombined.
On exit, RHO has been modified to the value required by
PSLAED3.
Z (global input) REAL array, dimension (N)
On entry, Z contains the updating vector (the last
row of the first sub-eigenvector matrix and the first row of
the second sub-eigenvector matrix).
On exit, the contents of Z have been destroyed by the updating
process.
DLAMDA (global output) REAL array, dimension (N)
A copy of the first K eigenvalues which will be used by
SLAED3 to form the secular equation.
W (global output) REAL array, dimension (N)
The first k values of the final deflation-altered z-vector
which will be passed to SLAED3.
Q2 (output) REAL array, dimension (LDQ2, NQ)
A copy of the first K eigenvectors which will be used by
LDQ2 (input) INTEGER
The leading dimension of the array Q2.
QBUF (workspace) REAL array, dimension 3*N
CTOT (workspace) INTEGER array, dimension( NPCOL, 4)
PSM (workspace) INTEGER array, dimension( NPCOL, 4)
NPCOL (global input) INTEGER
The total number of columns over which the distributed
submatrix is distributed.
INDX (workspace) INTEGER array, dimension (N)
The permutation used to sort the contents of DLAMDA into
ascending order.
INDXC (output) INTEGER array, dimension (N)
The permutation used to arrange the columns of the deflated
Q matrix into three groups: the first group contains non-zero
elements only at and above N1, the second contains
non-zero elements only below N1, and the third is dense.
INDXP (workspace) INTEGER array, dimension (N)
The permutation used to place deflated values of D at the end
of the array. INDXP(1:K) points to the nondeflated D-values
and INDXP(K+1:N) points to the deflated eigenvalues.
INDCOL (workspace) INTEGER array, dimension (N)
COLTYP (workspace/output) INTEGER array, dimension (N)
During execution, a label which will indicate which of the
following types a column in the Q2 matrix is:
1 : non-zero in the upper half only;
2 : dense;
3 : non-zero in the lower half only;
4 : deflated.
NN (global output) INTEGER, the order of matrix U, (PSLAED1).
NN1 (global output) INTEGER, the order of matrix Q1, (PSLAED1).
NN2 (global output) INTEGER, the order of matrix Q2, (PSLAED1).
IB1 (global output) INTEGER, pointeur on Q1, (PSLAED1).
IB2 (global output) INTEGER, pointeur on Q2, (PSLAED1).
=====================================================================
.. Parameters ..
|
|
|
|
001 SUBROUTINE PSLAED2( ICTXT , K , N , N1 , NB , D , DROW , DCOL , Q , LDQ ,
002 $RHO , Z , W , DLAMDA , Q2 , LDQ2 , QBUF , CTOT , PSM ,
003 $NPCOL , INDX , INDXC , INDXP , INDCOL , COLTYP , NN ,
004 $NN1 , NN2 , IB1 , IB2 )
005
006 * -- ScaLAPACK auxiliary routine(version 1.7) --
007 * University of Tennessee , Knoxville , Oak Ridge National Laboratory ,
008 * and University of California , Berkeley.
009 * December 31 , 1998
010
011 * .. Scalar Arguments ..
012 INTEGER DCOL , DROW , IB1 , IB2 , ICTXT , K , LDQ , LDQ2 , N ,
013 $N1 , NB , NN , NN1 , NN2 , NPCOL
014 REAL RHO
015 REAL MONE , ZERO , ONE , TWO , EIGHT
016 PARAMETER( MONE = - 1.0E0 , ZERO = 0.0E0 , ONE = 1.0E0 ,
017 $TWO = 2.0E0 , EIGHT = 8.0E0 )
018 * ..
019 * .. Local Scalars ..
020 INTEGER COL , CT , I , IAM , IE1 , IE2 , IMAX , INFO , J , JJQ2 ,
021 $JJS , JMAX , JS , K2 , MYCOL , MYROW , N1P1 , N2 , NJ ,
022 $NJCOL , NJJ , NP , NPROCS , NPROW , PJ , PJCOL , PJJ
023 REAL C , EPS , S , T , TAU , TOL
024 * ..
025 * .. External Functions ..
026 INTEGER INDXG2L , INDXL2G , ISAMAX , NUMROC
027 REAL PSLAMCH , SLAPY2
028 EXTERNAL INDXG2L , INDXL2G , ISAMAX , NUMROC , PSLAMCH ,
029 $SLAPY2
030 * ..
031 * .. External Subroutines ..
032 EXTERNAL BLACS_GRIDINFO , BLACS_PINFO , INFOG1L , SCOPY ,
033 $SGERV2D , SGESD2D , SLAPST , SROT , SSCAL
034 * ..
035 * .. Intrinsic Functions ..
036 INTRINSIC ABS , MAX , MIN , MOD , SQRT
037 * ..
038 * .. External Functions ..
039 * ..
040 * .. Local Arrays ..
041 INTEGER PTT( 4 )
042 * ..
043 * .. Executable Statements ..
044
045 * Quick return if possible
046
047 IF( N.EQ.0 )
047  
048 $ RETURN
049
050 CALL BLACS_PINFO( IAM , NPROCS )
051 CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
052 NP = NUMROC( N , NB , MYROW , DROW , NPROW )
053
054 N2 = N - N1
055 N1P1 = N1 + 1
056
057 IF( RHO.LT.ZERO ) THEN
057
058 CALL SSCAL( N2 , MONE , Z( N1P1 ) , 1 )
059 END IF
060
061 * Normalize z so that norm(z) = 1. Since z is the concatenation of
062 * two normalized vectors , norm2(z) = sqrt(2).
063
064 T = ONE / SQRT( TWO )
065 CALL SSCAL( N , T , Z , 1 )
066
067 * RHO = ABS( norm(z)**2 * RHO )
068
069 RHO = ABS( TWO*RHO )
070
071 * Calculate the allowable deflation tolerance
072
073 IMAX = ISAMAX( N , Z , 1 )
074 JMAX = ISAMAX( N , D , 1 )
075 EPS = PSLAMCH( ICTXT , 'Epsilon' )
076 TOL = EIGHT*EPS*MAX( ABS( D( JMAX ) ) , ABS( Z( IMAX ) ) )
077
078 * If the rank - 1 modifier is small enough , no more needs to be done
079 * except to reorganize Q so that its columns correspond with the
080 * elements in D.
081
082 IF( RHO*ABS( Z( IMAX ) ).LE.TOL ) THEN
082
083 K = 0
084 GO TO 220
085 END IF
086
087 * If there are multiple eigenvalues then the problem deflates. Here
088 * the number of equal eigenvalues are found. As each equal
089 * eigenvalue is found , an elementary reflector is computed to rotate
090 * the corresponding eigensubspace so that the corresponding
091 * components of Z are zero in this new basis.
092
093 CALL SLAPST ( 'I' , N , D , INDX , INFO )
094
095 DO 10 I = 1 , N1
095
096 COLTYP( I ) = 1
097 10 CONTINUE
097
098 DO 20 I = N1P1 , N
098
099 COLTYP( I ) = 3
100 20 CONTINUE
100
101 COL = DCOL
102 DO 40 I = 1 , N , NB
102
103 DO 30 J = 0 , NB - 1
103
104 IF( I + J.LE.N )
104
105 $ INDCOL( I + J ) = COL
106 30 CONTINUE
106
107 COL = MOD( COL + 1 , NPCOL )
108 40 CONTINUE
109
109
110 K = 0
111 K2 = N + 1
112 DO 50 J = 1 , N
112
113 NJ = INDX( J )
114 IF( RHO*ABS( Z( NJ ) ).LE.TOL ) THEN
115
116 * Deflate due to small z component.
117
117
118 K2 = K2 - 1
119 COLTYP( NJ ) = 4
120 INDXP( K2 ) = NJ
121 IF( J.EQ.N )
121
122 $ GO TO 80
123 ELSE
123
124 PJ = NJ
125 GO TO 60
126 END IF
127 50 CONTINUE
128 60 CONTINUE
129 J = J + 1
130 NJ = INDX( J )
131 IF( J.GT.N )
131
132 $ GO TO 80
133 IF( RHO*ABS( Z( NJ ) ).LE.TOL ) THEN
134
135 * Deflate due to small z component.
136
136
137 K2 = K2 - 1
138 COLTYP( NJ ) = 4
139 INDXP( K2 ) = NJ
140 ELSE
141
142 * Check if eigenvalues are close enough to allow deflation.
143
143
144 S = Z( PJ )
145 C = Z( NJ )
146
147 * Find sqrt(a**2 + b**2) without overflow or
148 * destructive underflow.
149
150 TAU = SLAPY2( C , S )
151 T = D( NJ ) - D( PJ )
152 C = C / TAU
153 S = - S / TAU
154 IF( ABS( T*C*S ).LE.TOL ) THEN
155
156 * Deflation is possible.
157
157
158 Z( NJ ) = TAU
159 Z( PJ ) = ZERO
160 IF( COLTYP( NJ ).NE.COLTYP( PJ ) )
160
161 $ COLTYP( NJ ) = 2
162 COLTYP( PJ ) = 4
163 CALL INFOG1L( NJ , NB , NPCOL , MYCOL , DCOL , NJJ , NJCOL )
164 CALL INFOG1L( PJ , NB , NPCOL , MYCOL , DCOL , PJJ , PJCOL )
165 IF( INDCOL( PJ ).EQ.INDCOL( NJ ) .AND. MYCOL.EQ.NJCOL ) THEN
165
166 CALL SROT( NP , Q( 1 , PJJ ) , 1 , Q( 1 , NJJ ) , 1 , C , S )
167 ELSE IF( MYCOL.EQ.PJCOL ) THEN
167
168 CALL SGESD2D( ICTXT , NP , 1 , Q( 1 , PJJ ) , NP , MYROW ,
169 $ NJCOL )
170 CALL SGERV2D( ICTXT , NP , 1 , QBUF , NP , MYROW , NJCOL )
171 CALL SROT( NP , Q( 1 , PJJ ) , 1 , QBUF , 1 , C , S )
172 ELSE IF( MYCOL.EQ.NJCOL ) THEN
172
173 CALL SGESD2D( ICTXT , NP , 1 , Q( 1 , NJJ ) , NP , MYROW ,
174 $ PJCOL )
175 CALL SGERV2D( ICTXT , NP , 1 , QBUF , NP , MYROW , PJCOL )
176 CALL SROT( NP , QBUF , 1 , Q( 1 , NJJ ) , 1 , C , S )
177 END IF
178 T = D( PJ )*C**2 + D( NJ )*S**2
179 D( NJ ) = D( PJ )*S**2 + D( NJ )*C**2
180 D( PJ ) = T
181 K2 = K2 - 1
182 I = 1
183 70 CONTINUE
184 IF( K2 + I.LE.N ) THEN
184
185 IF( D( PJ ).LT.D( INDXP( K2 + I ) ) ) THEN
185
186 INDXP( K2 + I - 1 ) = INDXP( K2 + I )
187 INDXP( K2 + I ) = PJ
188 I = I + 1
189 GO TO 70
190 ELSE
190
191 INDXP( K2 + I - 1 ) = PJ
192 END IF
193 ELSE
193
194 INDXP( K2 + I - 1 ) = PJ
195 END IF
196 PJ = NJ
197 ELSE
197
198 K = K + 1
199 DLAMDA( K ) = D( PJ )
200 W( K ) = Z( PJ )
201 INDXP( K ) = PJ
202 PJ = NJ
203 END IF
204 END IF
205 GO TO 60
206 80 CONTINUE
207
208 * Record the last eigenvalue.
209
210 K = K + 1
211 DLAMDA( K ) = D( PJ )
212 W( K ) = Z( PJ )
213 INDXP( K ) = PJ
214
215 * Count up the total number of the various types of columns , then
216 * form a permutation which positions the four column types into
217 * four uniform groups(although one or more of these groups may be
218 * empty).
219
220 DO 100 J = 1 , 4
220
221 DO 90 I = 0 , NPCOL - 1
221
222 CTOT( I , J ) = 0
223 90 CONTINUE
223
224 PTT( J ) = 0
225 100 CONTINUE
226 DO 110 J = 1 , N
226
227 CT = COLTYP( J )
228 COL = INDCOL( J )
229 CTOT( COL , CT ) = CTOT( COL , CT ) + 1
230 110 CONTINUE
231
232 * PSM(*) = Position in SubMatrix(of types 1 through 4)
233
234 DO 120 COL = 0 , NPCOL - 1
234
235 PSM( COL , 1 ) = 1
236 PSM( COL , 2 ) = 1 + CTOT( COL , 1 )
237 PSM( COL , 3 ) = PSM( COL , 2 ) + CTOT( COL , 2 )
238 PSM( COL , 4 ) = PSM( COL , 3 ) + CTOT( COL , 3 )
239 120 CONTINUE
240 PTT( 1 ) = 1
241 DO 140 I = 2 , 4
241
242 CT = 0
243 DO 130 J = 0 , NPCOL - 1
243
244 CT = CT + CTOT( J , I - 1 )
245 130 CONTINUE
245
246 PTT( I ) = PTT( I - 1 ) + CT
247 140 CONTINUE
248
249 * Fill out the INDXC array so that the permutation which it induces
250 * will place all type - 1 columns first , all type - 2 columns next ,
251 * then all type - 3's , and finally all type - 4's.
252
253 DO 150 J = 1 , N
253
254 JS = INDXP( J )
255 COL = INDCOL( JS )
256 CT = COLTYP( JS )
257 I = INDXL2G( PSM( COL , CT ) , NB , COL , DCOL , NPCOL )
258 INDX( J ) = I
259 INDXC( PTT( CT ) ) = I
260 PSM( COL , CT ) = PSM( COL , CT ) + 1
261 PTT( CT ) = PTT( CT ) + 1
262 150 CONTINUE
263 DO 160 J = 1 , N
263
264 JS = INDXP( J )
265 JJS = INDXG2L( JS , NB , J , J , NPCOL )
266 COL = INDCOL( JS )
267 IF( COL.EQ.MYCOL ) THEN
267
268 I = INDX( J )
269 JJQ2 = INDXG2L( I , NB , J , J , NPCOL )
270 CALL SCOPY( NP , Q( 1 , JJS ) , 1 , Q2( 1 , JJQ2 ) , 1 )
271 END IF
272 160 CONTINUE
273
274 * The deflated eigenvalues and their corresponding vectors go back
275 * into the last N - K slots of D and Q respectively.
276
277 CALL SCOPY( N , D , 1 , Z , 1 )
278 DO 170 J = K + 1 , N
278
279 JS = INDXP( J )
280 I = INDX( J )
281 D( I ) = Z( JS )
282 170 CONTINUE
283
284 PTT( 1 ) = 1
285 DO 190 I = 2 , 4
285
286 CT = 0
287 DO 180 J = 0 , NPCOL - 1
287
288 CT = CT + CTOT( J , I - 1 )
289 180 CONTINUE
289
290 PTT( I ) = PTT( I - 1 ) + CT
291 190 CONTINUE
292
293 IB1 = INDXC( 1 )
294 IE1 = IB1
295 IB2 = INDXC( PTT( 2 ) )
296 IE2 = IB2
297 DO 200 I = 2 , PTT( 3 ) - 1
297
298 IB1 = MIN( IB1 , INDXC( I ) )
299 IE1 = MAX( IE1 , INDXC( I ) )
300 200 CONTINUE
301 DO 210 I = PTT( 2 ) , PTT( 4 ) - 1
301
302 IB2 = MIN( IB2 , INDXC( I ) )
303 IE2 = MAX( IE2 , INDXC( I ) )
304 210 CONTINUE
305 NN1 = IE1 - IB1 + 1
306 NN2 = IE2 - IB2 + 1
307 NN = MAX( IE1 , IE2 ) - MIN( IB1 , IB2 ) + 1
308 220 CONTINUE
309 RETURN
310
311 * End of PSLAED2
312
313 END43
46
|
|
Variables in Routine PSLAED2()
| Summary Report |
| Data Type | Quantity | Size(byte) |
| INTEGER | 51 | 216 |
| REAL | 21 | 84 |
| TOTAL | 72 | 300 |
List of Variables
INTEGER
| COL | CT | DCOL | DROW | I |
| IAM | IB1 | IB2 | ICTXT | IE1 |
| IE2 | IMAX | INDCOL | INDX | INDXC |
| INDXG2L | INDXL2G | INDXP | INFO | ISAMAX |
| J | JJQ2 | JJS | JMAX | JS |
| K | K2 | LDQ | LDQ2 | MYCOL |
| MYROW | N | N1 | N1P1 | N2 |
| NB | NJ | NJCOL | NJJ | NN |
| NN1 | NN2 | NP | NPCOL | NPROCS |
| NPROW | NUMROC | PJ | PJCOL | PJJ |
| PTT( 4 ) | | | | |
REAL
| C | COLTYP | CTOT | D | DLAMDA |
| EIGHT | EPS | MONE | ONE | PSLAMCH |
| PSM | RHO | S | SLAPY2 | T |
| TAU | TOL | TWO | W | Z |
| ZERO | | | | |
Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence | | - | | - | - | | C | <--- | CC = C / TAU, NJC = Z( NJ ), TAUC = C / TAU, ZC = Z( NJ ) |
| COL | <--- | COLCOL = MOD( COL+1, NPCOL ), INDCOLCOL = INDCOL( J ){2COL = INDCOL( JS ), 3COL = INDCOL( JS )}, JCOL = INDCOL( J ), JSCOL = INDCOL( JS ){2COL = INDCOL( JS )}, NPCOLCOL = MOD( COL+1, NPCOL ){2DO 120 COL = 0, NPCOL - 1}, DCOLCOL = DCOL |
| CT | <--- | ICT = CT + CTOT( J, I-1 ){2CT = CT + CTOT( J, I-1 )}, JCT = COLTYP( J ){2CT = CT + CTOT( J, I-1 ), 3CT = CT + CTOT( J, I-1 )}, COLTYPCT = COLTYP( J ){2CT = COLTYP( JS )}, JSCT = COLTYP( JS ), CTCT = CT + CTOT( J, I-1 ){2CT = CT + CTOT( J, I-1 )}, CTOTCT = CT + CTOT( J, I-1 ){2CT = CT + CTOT( J, I-1 )} |
| CTOT | <--- | COLCTOT( COL, CT ) = CTOT( COL, CT ) + 1, CTCTOT( COL, CT ) = CTOT( COL, CT ) + 1, CTOTCTOT( COL, CT ) = CTOT( COL, CT ) + 1 |
| D | <--- | CD( NJ ) = D( PJ )*S**2 + D( NJ )*C**2, JSD( I ) = Z( JS ), NJD( NJ ) = D( PJ )*S**2 + D( NJ )*C**2, PJD( NJ ) = D( PJ )*S**2 + D( NJ )*C**2, DD( NJ ) = D( PJ )*S**2 + D( NJ )*C**2, SD( NJ ) = D( PJ )*S**2 + D( NJ )*C**2, TD( PJ ) = T, ZD( I ) = Z( JS ) |
| DLAMDA | <--- | PJDLAMDA( K ) = D( PJ ){2DLAMDA( K ) = D( PJ )}, DDLAMDA( K ) = D( PJ ){2DLAMDA( K ) = D( PJ )} |
| EPS | <--- | ICTXTEPS = PSLAMCH( ICTXT, 'Epsilon' ), PSLAMCHEPS = PSLAMCH( ICTXT, 'Epsilon' ) |
| I | <--- | II = I + 1, COLI = INDXL2G( PSM( COL, CT ), NB, COL, DCOL, NPCOL ), INDXI = INDX( J ){2I = INDX( J )}, INDXL2GI = INDXL2G( PSM( COL, CT ), NB, COL, DCOL, NPCOL ), JI = INDX( J ){2I = INDX( J )}, CTI = INDXL2G( PSM( COL, CT ), NB, COL, DCOL, NPCOL ), NDO 40 I = 1, N, NB{2DO 20 I = N1P1, N}, N1DO 10 I = 1, N1, N1P1DO 20 I = N1P1, N, NBDO 40 I = 1, N, NB{2I = INDXL2G( PSM( COL, CT ), NB, COL, DCOL, NPCOL )}, NPCOLDO 90 I = 0, NPCOL - 1{2I = INDXL2G( PSM( COL, CT ), NB, COL, DCOL, NPCOL )}, PSMI = INDXL2G( PSM( COL, CT ), NB, COL, DCOL, NPCOL ), PTTDO 200 I = 2, PTT( 3 ) - 1{2DO 210 I = PTT( 2 ), PTT( 4 ) - 1}, DCOLI = INDXL2G( PSM( COL, CT ), NB, COL, DCOL, NPCOL ) |
| IB1 | <--- | IIB1 = MIN( IB1, INDXC( I ) ), IB1IB1 = MIN( IB1, INDXC( I ) ), INDXCIB1 = INDXC( 1 ){2IB1 = MIN( IB1, INDXC( I ) )} |
| IB2 | <--- | IIB2 = MIN( IB2, INDXC( I ) ), IB2IB2 = MIN( IB2, INDXC( I ) ), INDXCIB2 = INDXC( PTT( 2 ) ){2IB2 = MIN( IB2, INDXC( I ) )}, PTTIB2 = INDXC( PTT( 2 ) ) |
| IE1 | <--- | IIE1 = MAX( IE1, INDXC( I ) ), IB1IE1 = IB1, IE1IE1 = MAX( IE1, INDXC( I ) ), INDXCIE1 = MAX( IE1, INDXC( I ) ) |
| IE2 | <--- | IIE2 = MAX( IE2, INDXC( I ) ), IB2IE2 = IB2, IE2IE2 = MAX( IE2, INDXC( I ) ), INDXCIE2 = MAX( IE2, INDXC( I ) ) |
| IMAX | <--- | ISAMAXIMAX = ISAMAX( N, Z, 1 ), NIMAX = ISAMAX( N, Z, 1 ), ZIMAX = ISAMAX( N, Z, 1 ) |
| INDX | <--- | IINDX( J ) = I |
| INDXC | <--- | IINDXC( PTT( CT ) ) = I |
| INDXP | <--- | IINDXP( K2+I-1 ) = INDXP( K2+I ), INDXPINDXP( K2+I-1 ) = INDXP( K2+I ), K2INDXP( K2+I-1 ) = INDXP( K2+I ), NJINDXP( K2 ) = NJ{2INDXP( K2 ) = NJ}, PJINDXP( K2+I ) = PJ{2INDXP( K2+I-1 ) = PJ, 3INDXP( K2+I-1 ) = PJ, 4INDXP( K ) = PJ, 5INDXP( K ) = PJ} |
| J | <--- | JJ = J + 1, KDO 170 J = K + 1, N, NDO 50 J = 1, N{2DO 110 J = 1, N, 3DO 150 J = 1, N, 4DO 160 J = 1, N, 5DO 170 J = K + 1, N}, NBDO 30 J = 0, NB - 1, NPCOLDO 130 J = 0, NPCOL - 1{2DO 180 J = 0, NPCOL - 1} |
| JJQ2 | <--- | IJJQ2 = INDXG2L( I, NB, J, J, NPCOL ), INDXG2LJJQ2 = INDXG2L( I, NB, J, J, NPCOL ), JJJQ2 = INDXG2L( I, NB, J, J, NPCOL ), NBJJQ2 = INDXG2L( I, NB, J, J, NPCOL ), NPCOLJJQ2 = INDXG2L( I, NB, J, J, NPCOL ) |
| JJS | <--- | INDXG2LJJS = INDXG2L( JS, NB, J, J, NPCOL ), JJJS = INDXG2L( JS, NB, J, J, NPCOL ), JSJJS = INDXG2L( JS, NB, J, J, NPCOL ), NBJJS = INDXG2L( JS, NB, J, J, NPCOL ), NPCOLJJS = INDXG2L( JS, NB, J, J, NPCOL ) |
| JMAX | <--- | ISAMAXJMAX = ISAMAX( N, D, 1 ), NJMAX = ISAMAX( N, D, 1 ), DJMAX = ISAMAX( N, D, 1 ) |
| JS | <--- | INDXPJS = INDXP( J ){2JS = INDXP( J ), 3JS = INDXP( J )}, JJS = INDXP( J ){2JS = INDXP( J ), 3JS = INDXP( J )} |
| K | <--- | KK = K + 1{2K = K + 1} |
| K2 | <--- | K2K2 = K2 - 1{2K2 = K2 - 1, 3K2 = K2 - 1}, NK2 = N + 1 |
| N1P1 | <--- | N1N1P1 = N1 + 1 |
| N2 | <--- | NN2 = N - N1, N1N2 = N - N1 |
| NJ | <--- | INDXNJ = INDX( J ){2NJ = INDX( J )}, JNJ = INDX( J ){2NJ = INDX( J )} |
| NN | <--- | IB1NN = MAX( IE1, IE2 ) - MIN( IB1, IB2 ) + 1, IB2NN = MAX( IE1, IE2 ) - MIN( IB1, IB2 ) + 1, IE1NN = MAX( IE1, IE2 ) - MIN( IB1, IB2 ) + 1, IE2NN = MAX( IE1, IE2 ) - MIN( IB1, IB2 ) + 1 |
| NN1 | <--- | IB1NN1 = IE1 - IB1 + 1, IE1NN1 = IE1 - IB1 + 1 |
| NN2 | <--- | IB2NN2 = IE2 - IB2 + 1, IE2NN2 = IE2 - IB2 + 1 |
| NP | <--- | MYROWNP = NUMROC( N, NB, MYROW, DROW, NPROW ), NNP = NUMROC( N, NB, MYROW, DROW, NPROW ), NBNP = NUMROC( N, NB, MYROW, DROW, NPROW ), NPROWNP = NUMROC( N, NB, MYROW, DROW, NPROW ), NUMROCNP = NUMROC( N, NB, MYROW, DROW, NPROW ), DROWNP = NUMROC( N, NB, MYROW, DROW, NPROW ) |
| PJ | <--- | NJPJ = NJ{2PJ = NJ, 3PJ = NJ} |
| PSM | <--- | COLPSM( COL, 2 ) = 1 + CTOT( COL, 1 ){2PSM( COL, 3 ) = PSM( COL, 2 ) + CTOT( COL, 2 ), 3PSM( COL, 4 ) = PSM( COL, 3 ) + CTOT( COL, 3 ), 4PSM( COL, CT ) = PSM( COL, CT ) + 1}, CTPSM( COL, CT ) = PSM( COL, CT ) + 1, CTOTPSM( COL, 2 ) = 1 + CTOT( COL, 1 ){2PSM( COL, 3 ) = PSM( COL, 2 ) + CTOT( COL, 2 ), 3PSM( COL, 4 ) = PSM( COL, 3 ) + CTOT( COL, 3 )}, PSMPSM( COL, 3 ) = PSM( COL, 2 ) + CTOT( COL, 2 ){2PSM( COL, 4 ) = PSM( COL, 3 ) + CTOT( COL, 3 ), 3PSM( COL, CT ) = PSM( COL, CT ) + 1} |
| PTT | <--- | IPTT( I ) = PTT( I-1 ) + CT{2PTT( I ) = PTT( I-1 ) + CT}, CTPTT( I ) = PTT( I-1 ) + CT{2PTT( CT ) = PTT( CT ) + 1, 3PTT( I ) = PTT( I-1 ) + CT}, PTTPTT( I ) = PTT( I-1 ) + CT{2PTT( CT ) = PTT( CT ) + 1, 3PTT( I ) = PTT( I-1 ) + CT} |
| RHO | <--- | RHORHO = ABS( TWO*RHO ), TWORHO = ABS( TWO*RHO ) |
| S | <--- | PJS = Z( PJ ), SS = -S / TAU, TAUS = -S / TAU, ZS = Z( PJ ) |
| T | <--- | CT = D( PJ )*C**2 + D( NJ )*S**2, NJT = D( NJ ) - D( PJ ){2T = D( PJ )*C**2 + D( NJ )*S**2}, ONET = ONE / SQRT( TWO ), PJT = D( NJ ) - D( PJ ){2T = D( PJ )*C**2 + D( NJ )*S**2}, DT = D( NJ ) - D( PJ ){2T = D( PJ )*C**2 + D( NJ )*S**2}, ST = D( PJ )*C**2 + D( NJ )*S**2, TWOT = ONE / SQRT( TWO ) |
| TAU | <--- | CTAU = SLAPY2( C, S ), STAU = SLAPY2( C, S ), SLAPY2TAU = SLAPY2( C, S ) |
| TOL | <--- | EIGHTTOL = EIGHT*EPS*MAX( ABS( D( JMAX ) ), ABS( Z( IMAX ) ) ), EPSTOL = EIGHT*EPS*MAX( ABS( D( JMAX ) ), ABS( Z( IMAX ) ) ), IMAXTOL = EIGHT*EPS*MAX( ABS( D( JMAX ) ), ABS( Z( IMAX ) ) ), JMAXTOL = EIGHT*EPS*MAX( ABS( D( JMAX ) ), ABS( Z( IMAX ) ) ), DTOL = EIGHT*EPS*MAX( ABS( D( JMAX ) ), ABS( Z( IMAX ) ) ), ZTOL = EIGHT*EPS*MAX( ABS( D( JMAX ) ), ABS( Z( IMAX ) ) ) |
| W | <--- | PJW( K ) = Z( PJ ){2W( K ) = Z( PJ )}, ZW( K ) = Z( PJ ){2W( K ) = Z( PJ )} |
| Z | <--- | TAUZ( NJ ) = TAU, ZEROZ( PJ ) = ZERO |
|
|
Analysis elements of the routine PSLAED2()
Put the mouse over each element to display detailed matching information
 Assigned variables |
| | | C , COL , CT , EIGHT , EPS , I , IB1 , IB2 , IE1 , IE2 , IMAX , J , JJQ2 , JJS , JMAX , JS , K , K2 , MONE , N1P1 , N2 , NJ , NN , NN1 , NN2 , NP , ONE , PJ , PSM , PTT , RHO , S , T , TAU , TOL , TWO , z , ZERO |
|
| Active variables |
| | | C , COL , COLTYP , CT , CTOT , D , DCOL , DLAMDA , DROW , EIGHT , EPS , I , IAM , IB1 , IB2 , ICTXT , IE1 , IE2 , IMAX , INDCOL , INDX , INDXC , INDXG2L , INDXL2G , INDXP , INFO , ISAMAX , J , JJQ2 , JJS , JMAX , JS , K , K2 , LDQ , LDQ2 , MONE , MYCOL , MYROW , N , N1 , N1P1 , N2 , NB , NJ , NJCOL , NJJ , NN , NN1 , NN2 , NP , NPCOL , NPROCS , NPROW , NUMROC , ONE , PJ , PJCOL , PJJ , PSLAMCH , PSM , PTT , Q , Q2 , QBUF , RHO , S , SLAPY2 , T , TAU , TOL , TWO , W , Z , ZERO |
|
| Allocated variables [ statement : associated variable ] |
| |  new | : this |
|
| Accessed arrays [ array name : associated index ] |
| | COLTYP | : I , I , J , JS , NJ , NJ , NJ , NJ , PJ , PJ |
| | CTOT | : COL, 1 , COL, 2 , COL, 3 , COL, CT , I, J , J, I-1 , J, I-1 |
| | D | : I , INDXP( K2+I ) , JMAX , NJ , NJ , NJ , PJ , PJ , PJ , PJ , PJ , PJ , PJ |
| | DLAMDA | : K , K |
| | INDCOL | : I+J , J , JS , JS , NJ , PJ |
| | INDX | : J , J , J , J , J |
| | INDXC | : 1 , I , I , I , I , PTT( 2 ) , PTT( CT ) |
| | INDXG2L | : I, NB, J, J, NPCOL , JS, NB, J, J, NPCOL |
| | INDXL2G | : PSM( COL, CT ), NB, COL, DCOL, NPCOL |
| | INDXP | : J , J , J , K , K , K2 , K2 , K2+I , K2+I , K2+I , K2+I-1 , K2+I-1 , K2+I-1 |
| | ISAMAX | : N, D, 1 , N, Z, 1 |
| | NUMROC | : N, NB, MYROW, DROW, NPROW |
| | PSLAMCH | : ICTXT, 'Epsilon' |
| | PSM | : * , COL, 1 , COL, 2 , COL, 2 , COL, 3 , COL, 3 , COL, 4 , COL, CT , COL, CT |
| | PTT | : 1 , 1 , 2 , 2 , 3 , 4 , 4 , CT , CT , I , I , I-1 , I-1 , J |
| | Q | : 1, JJS , 1, NJJ , 1, NJJ , 1, NJJ , 1, PJJ , 1, PJJ , 1, PJJ |
| | Q2 | : 1, JJQ2 |
| | SLAPY2 | : C, S |
| | W | : K , K |
| | Z | : IMAX , IMAX , JS , N1P1 , NJ , NJ , NJ , NJ , PJ , PJ , PJ , PJ |
|
| Conditional statements [ statement : associated predicate ] |
| | do | : ( 10 I = 1 , N1 ) , ( 20 I = N1P1 , N ) , ( 40 I = 1 , N , NB ) , ( 30 J = 0 , NB - 1 ) , ( 50 J = 1 , N ) , ( 100 J = 1 , 4 ) , ( 90 I = 0 , NPCOL - 1 ) , ( 110 J = 1 , N ) , ( 120 COL = 0 , NPCOL - 1 ) , ( 140 I = 2 , 4 ) , ( 130 J = 0 , NPCOL - 1 ) , ( 150 J = 1 , N ) , ( 160 J = 1 , N ) , ( 170 J = K + 1 , N ) , ( 190 I = 2 , 4 ) , ( 180 J = 0 , NPCOL - 1 ) , ( 200 I = 2 , PTT( 3 ) - 1 ) , ( 210 I = PTT( 2 ) , PTT( 4 ) - 1 ) |
| | if | : ( possible ) , ( N.EQ.0 ) , ( RHO.LT.ZERO ) , ( the rank - 1 modifier is small enough , no more needs to be done ) , ( (RHO*ABS( Z( IMAX ) ).LE.TOL ) ) , ( there are multiple eigenvalues ) , ( I+J.LE.N ) , ( (RHO*ABS( Z( NJ ) ).LE.TOL ) ) , ( J.EQ.N ) , ( J.GT.N ) , ( (RHO*ABS( Z( NJ ) ).LE.TOL ) ) , ( eigenvalues are close enough to allow deflation. ) , ( (ABS( T*C*S ).LE.TOL ) ) , ( (COLTYP( NJ ).NE.COLTYP( PJ ) ) ) , ( (INDCOL( PJ ).EQ.INDCOL( NJ ) .AND. MYCOL.EQ.NJCOL ) ) , ( MYCOL.EQ.PJCOL ) , ( MYCOL.EQ.NJCOL ) , ( K2+I.LE.N ) , ( (D( PJ ).LT.D( INDXP( K2 + I ) ) ) ) , ( COL.EQ.MYCOL ) |
|
| List of variables |
C
COL
COLTYP
CT
CTOT
D
DCOL
| DLAMDA
DROW
EIGHT
EPS
I
IAM
IB1
IB2
| ICTXT
IE1
IE2
IMAX
INDCOL
INDX
INDXC
INDXG2L
| INDXL2G
INDXP
INFO
ISAMAX
J
JJQ2
JJS
JMAX
| JS
K
K2
LDQ
LDQ2
MONE
MYCOL
MYROW
| N
N1
N1P1
N2
NB
NJ
NJCOL
NJJ
| NN
NN1
NN2
NP
NPCOL
NPROCS
NPROW
NUMROC
| ONE
PJ
PJCOL
PJJ
PSLAMCH
PSM
PTT( 4 )
RHO
| S
SLAPY2
T
TAU
TOL
TWO
W
Z
| ZERO | | close
| |
C
COL
COLTYP
CT
CTOT
D
DCOL
DLAMDA
DROW
EIGHT
EPS
I
IAM
IB1
IB2
ICTXT
IE1
IE2
IMAX
INDCOL
INDX
INDXC
INDXG2L
INDXL2G
INDXP
INFO
ISAMAX
J
JJQ2
JJS
JMAX
JS
K
K2
LDQ
LDQ2
MONE
MYCOL
MYROW
N
N1
N1P1
N2
NB
NJ
NJCOL
NJJ
NN
NN1
NN2
NP
NPCOL
NPROCS
NPROW
NUMROC
ONE
PJ
PJCOL
PJJ
PSLAMCH
PSM
PTT( 4 )
RHO
S
SLAPY2
T
TAU
TOL
TWO
W
Z
ZERO
369#606
| |
