|
|
| |
| # lines: |
352 | | # code: |
352 | | # comment: | 0 | |
# blank: | 0 |
| # Variables: | 70 |
| # Callers: | 0 |
| # Callings: | 8 |
| # Words: | 209 |
| # Keywords: | 126 |
|
|
|
|
|
..
.. Array Arguments ..
..
Purpose
=======
PDSYEVD computes all the eigenvalues and eigenvectors
of a real symmetric matrix A by calling the recommended sequence
of ScaLAPACK routines.
In its present form, PDSYEVD assumes a homogeneous system and makes
no checks for consistency of the eigenvalues or eigenvectors across
the different processes. Because of this, it is possible that a
heterogeneous system may return incorrect results without any error
messages.
Arguments
=========
NP = the number of rows local to a given process.
NQ = the number of columns local to a given process.
JOBZ (input) CHARACTER*1
= 'N': Compute eigenvalues only; (NOT IMPLEMENTED YET)
= 'V': Compute eigenvalues and eigenvectors.
UPLO (global input) CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N (global input) INTEGER
The number of rows and columns to be operated on, i.e. the
order of the distributed submatrix sub( A ). N >= 0.
A (local input/workspace) block cyclic DOUBLE PRECISION array,
global dimension (N, N), local dimension ( LLD_A,
LOCc(JA+N-1) )
On entry, the symmetric matrix A. If UPLO = 'U', only the
upper triangular part of A is used to define the elements of
the symmetric matrix. If UPLO = 'L', only the lower
triangular part of A is used to define the elements of the
symmetric matrix.
On exit, the lower triangle (if UPLO='L') or the upper
triangle (if UPLO='U') of A, including the diagonal, is
destroyed.
IA (global input) INTEGER
A's global row index, which points to the beginning of the
submatrix which is to be operated on.
JA (global input) INTEGER
A's global column index, which points to the beginning of
the submatrix which is to be operated on.
DESCA (global and local input) INTEGER array of dimension DLEN_.
The array descriptor for the distributed matrix A.
W (global output) DOUBLE PRECISION array, dimension (N)
If INFO=0, the eigenvalues in ascending order.
Z (local output) DOUBLE PRECISION array,
global dimension (N, N),
local dimension ( LLD_Z, LOCc(JZ+N-1) )
Z contains the orthonormal eigenvectors
of the symmetric matrix A.
IZ (global input) INTEGER
Z's global row index, which points to the beginning of the
submatrix which is to be operated on.
JZ (global input) INTEGER
Z's global column index, which points to the beginning of
the submatrix which is to be operated on.
DESCZ (global and local input) INTEGER array of dimension DLEN_.
The array descriptor for the distributed matrix Z.
DESCZ( CTXT_ ) must equal DESCA( CTXT_ )
WORK (local workspace/output) DOUBLE PRECISION array,
dimension (LWORK)
On output, WORK(1) returns the workspace required.
LWORK (local input) INTEGER
LWORK >= MAX( 1+6*N+2*NP*NQ, TRILWMIN ) + 2*N
TRILWMIN = 3*N + MAX( NB*( NP+1 ), 3*NB )
NP = NUMROC( N, NB, MYROW, IAROW, NPROW )
NQ = NUMROC( N, NB, MYCOL, IACOL, NPCOL )
If LWORK = -1, the LWORK is global input and a workspace
query is assumed; the routine only calculates the minimum
size for the WORK array. The required workspace is returned
as the first element of WORK and no error message is issued
by PXERBLA.
IWORK (local workspace/output) INTEGER array, dimension (LIWORK)
On exit, if LIWORK > 0, IWORK(1) returns the optimal LIWORK.
LIWORK (input) INTEGER
The dimension of the array IWORK.
LIWORK = 7*N + 8*NPCOL + 2
INFO (global output) INTEGER
= 0: successful exit
< 0: If the i-th argument is an array and the j-entry had
an illegal value, then INFO = -(i*100+j), if the i-th
argument is a scalar and had an illegal value, then
INFO = -i.
> 0: The algorithm failed to compute the INFO/(N+1) th
eigenvalue while working on the submatrix lying in
global rows and columns mod(INFO,N+1).
Alignment requirements
======================
The distributed submatrices sub( A ), sub( Z ) must verify
some alignment properties, namely the following expression
should be true:
( MB_A.EQ.NB_A.EQ.MB_Z.EQ.NB_Z .AND. IROFFA.EQ.ICOFFA .AND.
IROFFA.EQ.0 .AND.IROFFA.EQ.IROFFZ. AND. IAROW.EQ.IZROW)
with IROFFA = MOD( IA-1, MB_A )
and ICOFFA = MOD( JA-1, NB_A ).
Further Details
======= =======
Contributed by Francoise Tisseur, University of Manchester.
Reference: F. Tisseur and J. Dongarra, "A Parallel Divide and
Conquer Algorithm for the Symmetric Eigenvalue Problem
on Distributed Memory Architectures",
SIAM J. Sci. Comput., 6:20 (1999), pp. 2223--2236.
(see also LAPACK Working Note 132)
http://www.netlib.org/lapack/lawns/lawn132.ps
=====================================================================
.. Parameters ..
|
|
|
|
001 SUBROUTINE PDSYEVD( JOBZ , UPLO , N , A , IA , JA , DESCA , W , Z , IZ , JZ ,
002 $DESCZ , WORK , LWORK , IWORK , LIWORK , INFO )
003
004 * -- ScaLAPACK routine(version 1.7) --
005 * University of Tennessee , Knoxville , Oak Ridge National Laboratory ,
006 * and University of California , Berkeley.
007 * March 14 , 2000
008
009 * .. Scalar Arguments ..
010 CHARACTER JOBZ , UPLO
011 INTEGER IA , INFO , IZ , JA , JZ , LIWORK , LWORK , N
012 INTEGER BLOCK_CYCLIC_2D , DLEN_ , DTYPE_ , CTXT_ , M_ , N_ ,
013 $MB_ , NB_ , RSRC_ , CSRC_ , LLD_
014 PARAMETER( BLOCK_CYCLIC_2D = 1 , DLEN_ = 9 , DTYPE_ = 1 ,
015 $CTXT_ = 2 , M_ = 3 , N_ = 4 , MB_ = 5 , NB_ = 6 ,
016 $RSRC_ = 7 , CSRC_ = 8 , LLD_ = 9 )
017 DOUBLE PRECISION ZERO , ONE
018 PARAMETER( ZERO = 0.0D + 0 , ONE = 1.0D + 0 )
019 * ..
020 * .. Local Scalars ..
021 LOGICAL LQUERY , UPPER
022 INTEGER IACOL , IAROW , ICOFFA , ICOFFZ , ICTXT , IINFO ,
023 $INDD , INDE , INDE2 , INDTAU , INDWORK , INDWORK2 ,
024 $IROFFA , IROFFZ , ISCALE , LIWMIN , LLWORK ,
025 $LLWORK2 , LWMIN , MYCOL , MYROW , NB , NP , NPCOL ,
026 $NPROW , NQ , OFFSET , TRILWMIN
027 DOUBLE PRECISION ANRM , BIGNUM , EPS , RMAX , RMIN , SAFMIN , SIGMA ,
028 $SMLNUM
029 * ..
030 * .. Local Arrays ..
031 * ..
032 INTEGER IDUM1( 2 ) , IDUM2( 2 )
033 * ..
034 * .. External Functions ..
035 LOGICAL LSAME
036 INTEGER INDXG2P , NUMROC
037 DOUBLE PRECISION PDLAMCH , PDLANSY
038 EXTERNAL LSAME , INDXG2P , NUMROC , PDLAMCH , PDLANSY
039 * ..
040 * .. External Subroutines ..
041 EXTERNAL BLACS_GRIDINFO , CHK1MAT , DSCAL , PCHK1MAT ,
042 $PDLARED1D , PDLASCL , PDLASET , PDORMTR , PDSTEDC ,
043 $PDSYTRD , PXERBLA
044 * ..
045 * .. Intrinsic Functions ..
046 INTRINSIC DBLE , ICHAR , MAX , MIN , MOD , SQRT
047 * ..
048 * .. Executable Statements ..
049 * This is just to keep ftnchek and toolpack / 1 happy
050 IF( BLOCK_CYCLIC_2D*CSRC_*CTXT_*DLEN_*DTYPE_*LLD_*MB_*M_*NB_*N_*
050  
051 $ RSRC_.LT.0 )RETURN
052
053 * Quick return
054
055 IF( N.EQ.0 )
055
056 $ RETURN
057
058 * Test the input arguments.
059
060 CALL BLACS_GRIDINFO( DESCZ( CTXT_ ) , NPROW , NPCOL , MYROW , MYCOL )
061
062 INFO = 0
063 IF( NPROW.EQ. - 1 ) THEN
063
064 INFO = - ( 600 + CTXT_ )
065 ELSE
065
066 CALL CHK1MAT( N , 3 , N , 3 , IA , JA , DESCA , 7 , INFO )
067 CALL CHK1MAT( N , 3 , N , 3 , IZ , JZ , DESCZ , 12 , INFO )
068 IF( INFO.EQ.0 ) THEN
068
069 UPPER = LSAME( UPLO , 'U' )
070 NB = DESCA( NB_ )
071 IROFFA = MOD( IA - 1 , DESCA( MB_ ) )
072 ICOFFA = MOD( JA - 1 , DESCA( NB_ ) )
073 IROFFZ = MOD( IZ - 1 , DESCZ( MB_ ) )
074 ICOFFZ = MOD( JZ - 1 , DESCZ( NB_ ) )
075 IAROW = INDXG2P( IA , NB , MYROW , DESCA( RSRC_ ) , NPROW )
076 IACOL = INDXG2P( JA , NB , MYCOL , DESCA( CSRC_ ) , NPCOL )
077 NP = NUMROC( N , NB , MYROW , IAROW , NPROW )
078 NQ = NUMROC( N , NB , MYCOL , IACOL , NPCOL )
079
080 LQUERY =( LWORK.EQ. - 1 )
081 TRILWMIN = 3*N + MAX( NB*( NP + 1 ) , 3*NB )
082 LWMIN = MAX( 1 + 6*N + 2*NP*NQ , TRILWMIN ) + 2*N
083 LIWMIN = 7*N + 8*NPCOL + 2
084 WORK( 1 ) = DBLE( LWMIN )
085 IWORK( 1 ) = LIWMIN
086 IF( .NOT.LSAME( JOBZ , 'V' ) ) THEN
086
087 INFO = - 1
088 ELSE IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO , 'L' ) ) THEN
088
089 INFO = - 2
090 ELSE IF( IROFFA.NE.ICOFFA .OR. ICOFFA.NE.0 ) THEN
090
091 INFO = - 6
092 ELSE IF( IROFFA.NE.IROFFZ .OR. ICOFFA.NE.ICOFFZ ) THEN
092
093 INFO = - 10
094 ELSE IF( DESCA( M_ ).NE.DESCZ( M_ ) ) THEN
094
095 INFO = - ( 1200 + M_ )
096 ELSE IF( DESCA( MB_ ).NE.DESCA( NB_ ) ) THEN
096
097 INFO = - ( 700 + NB_ )
098 ELSE IF( DESCZ( MB_ ).NE.DESCZ( NB_ ) ) THEN
098
099 INFO = - ( 1200 + NB_ )
100 ELSE IF( DESCA( MB_ ).NE.DESCZ( MB_ ) ) THEN
100
101 INFO = - ( 1200 + MB_ )
102 ELSE IF( DESCA( CTXT_ ).NE.DESCZ( CTXT_ ) ) THEN
102
103 INFO = - ( 1200 + CTXT_ )
104 ELSE IF( DESCA( RSRC_ ).NE.DESCZ( RSRC_ ) ) THEN
104
105 INFO = - ( 1200 + RSRC_ )
106 ELSE IF( DESCA( CSRC_ ).NE.DESCZ( CSRC_ ) ) THEN
106
107 INFO = - ( 1200 + CSRC_ )
108 ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
108
109 INFO = - 14
110 ELSE IF( LIWORK.LT.LIWMIN .AND. .NOT.LQUERY ) THEN
110
111 INFO = - 16
112 END IF
113 END IF
114 IF( UPPER ) THEN
114
115 IDUM1( 1 ) = ICHAR( 'U' )
116 ELSE
116
117 IDUM1( 1 ) = ICHAR( 'L' )
118 END IF
119 IDUM2( 1 ) = 2
120 IF( LWORK.EQ. - 1 ) THEN
120
121 IDUM1( 2 ) = - 1
122 ELSE
122
123 IDUM1( 2 ) = 1
124 END IF
125 IDUM2( 2 ) = 14
126 CALL PCHK1MAT( N , 3 , N , 3 , IA , JA , DESCA , 7 , 2 , IDUM1 , IDUM2 ,
127 $ INFO )
128 END IF
129 IF( INFO.NE.0 ) THEN
129
130 CALL PXERBLA( ICTXT , 'PDSYEVD' , - INFO )
131 RETURN
132 ELSE IF( LQUERY ) THEN
132
133 RETURN
134 END IF
135
136 * Set up pointers into the WORK array
137
138 INDTAU = 1
139 INDE = INDTAU + N
140 INDD = INDE + N
141 INDE2 = INDD + N
142 INDWORK = INDE2 + N
143 LLWORK = LWORK - INDWORK + 1
144 INDWORK2 = INDD
145 LLWORK2 = LWORK - INDWORK2 + 1
146
147 * Scale matrix to allowable range , if necessary.
148
149 ISCALE = 0
150 SAFMIN = PDLAMCH( DESCA( CTXT_ ) , 'Safe minimum' )
151 EPS = PDLAMCH( DESCA( CTXT_ ) , 'Precision' )
152 SMLNUM = SAFMIN / EPS
153 BIGNUM = ONE / SMLNUM
154 RMIN = SQRT( SMLNUM )
155 RMAX = MIN( SQRT( BIGNUM ) , ONE / SQRT( SQRT( SAFMIN ) ) )
156 ANRM = PDLANSY( 'M' , UPLO , N , A , IA , JA , DESCA , WORK( INDWORK ) )
157
158 IF( ANRM.GT.ZERO .AND. ANRM.LT.RMIN ) THEN
158
159 ISCALE = 1
160 SIGMA = RMIN / ANRM
161 ELSE IF( ANRM.GT.RMAX ) THEN
161
162 ISCALE = 1
163 SIGMA = RMAX / ANRM
164 END IF
165
166 IF( ISCALE.EQ.1 ) THEN
166
167 CALL PDLASCL ( UPLO , ONE , SIGMA , N , N , A , IA , JA , DESCA , IINFO )
168 END IF
169
170 * Reduce symmetric matrix to tridiagonal form.
171
172 CALL PDSYTRD ( UPLO , N , A , IA , JA , DESCA , WORK( INDD ) ,
173 $ WORK( INDE2 ) , WORK( INDTAU ) , WORK( INDWORK ) ,
174 $ LLWORK , IINFO )
175
176 * Copy the values of D , E to all processes.
177
178 CALL PDLARED1D ( N , IA , JA , DESCA , WORK( INDD ) , W ,
179 $ WORK( INDWORK ) , LLWORK )
180
181 CALL PDLARED1D ( N , IA , JA , DESCA , WORK( INDE2 ) , WORK( INDE ) ,
182 $ WORK( INDWORK ) , LLWORK )
183
184 CALL PDLASET ( 'Full' , N , N , ZERO , ONE , Z , 1 , 1 , DESCZ )
185
186 IF( UPPER ) THEN
186
187 OFFSET = 1
188 ELSE
188
189 OFFSET = 0
190 END IF
191 CALL PDSTEDC ( 'I' , N , W , WORK( INDE + OFFSET ) , Z , IZ , JZ , DESCZ ,
192 $ WORK( INDWORK2 ) , LLWORK2 , IWORK , LIWORK , INFO )
193
194 CALL PDORMTR ( 'L' , UPLO , 'N' , N , N , A , IA , JA , DESCA ,
195 $ WORK( INDTAU ) , Z , IZ , JZ , DESCZ , WORK( INDWORK2 ) ,
196 $ LLWORK2 , IINFO )
197
198 * If matrix was scaled , then rescale eigenvalues appropriately.
199
200 IF( ISCALE.EQ.1 ) THEN
200
201 CALL DSCAL( N , ONE / SIGMA , W , 1 )
202 END IF
203
204 RETURN
205
206 * End of PDSYEVD
207
208 END27
30
|
|
Variables in Routine PDSYEVD()
| Summary Report |
| Data Type | Quantity | Size(byte) |
| CHARACTER | 2 | 2 |
| DOUBLE PRECISION | 12 | 48 |
| INTEGER | 52 | 220 |
| LOGICAL | 3 | 3 |
| REAL | 1 | 4 |
| TOTAL | 70 | 277 |
List of Variables
CHARACTER
DOUBLE PRECISION
| ANRM | BIGNUM | EPS | ONE | PDLAMCH |
| PDLANSY | RMAX | RMIN | SAFMIN | SIGMA |
| SMLNUM | ZERO | | | |
INTEGER
| BLOCK_CYCLIC_2D | CSRC_ | CTXT_ | DLEN_ | DTYPE_ |
| IA | IACOL | IAROW | ICOFFA | ICOFFZ |
| ICTXT | IDUM1( 2 ) | IDUM2( 2 ) | IINFO | INDD |
| INDE | INDE2 | INDTAU | INDWORK | INDWORK2 |
| INDXG2P | INFO | IROFFA | IROFFZ | ISCALE |
| IWORK | IZ | JA | JZ | LIWMIN |
| LIWORK | LLD_ | LLWORK | LLWORK2 | LWMIN |
| LWORK | M_ | MB_ | MYCOL | MYROW |
| N | N_ | NB | NB_ | NP |
| NPCOL | NPROW | NQ | NUMROC | OFFSET |
| RSRC_ | TRILWMIN | | | |
LOGICAL
REAL
Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence | | - | | - | - | | ANRM | <--- | INDWORKANRM = PDLANSY( 'M', UPLO, N, A, IA, JA, DESCA, WORK( INDWORK ) ), JAANRM = PDLANSY( 'M', UPLO, N, A, IA, JA, DESCA, WORK( INDWORK ) ), NANRM = PDLANSY( 'M', UPLO, N, A, IA, JA, DESCA, WORK( INDWORK ) ), PDLANSYANRM = PDLANSY( 'M', UPLO, N, A, IA, JA, DESCA, WORK( INDWORK ) ), UPLOANRM = PDLANSY( 'M', UPLO, N, A, IA, JA, DESCA, WORK( INDWORK ) ), WORKANRM = PDLANSY( 'M', UPLO, N, A, IA, JA, DESCA, WORK( INDWORK ) ), IAANRM = PDLANSY( 'M', UPLO, N, A, IA, JA, DESCA, WORK( INDWORK ) ) |
| BIGNUM | <--- | ONEBIGNUM = ONE / SMLNUM, SMLNUMBIGNUM = ONE / SMLNUM |
| EPS | <--- | CTXT_EPS = PDLAMCH( DESCA( CTXT_ ), 'Precision' ), PDLAMCHEPS = PDLAMCH( DESCA( CTXT_ ), 'Precision' ) |
| IACOL | <--- | INDXG2PIACOL = INDXG2P( JA, NB, MYCOL, DESCA( CSRC_ ), NPCOL ), JAIACOL = INDXG2P( JA, NB, MYCOL, DESCA( CSRC_ ), NPCOL ), CSRC_IACOL = INDXG2P( JA, NB, MYCOL, DESCA( CSRC_ ), NPCOL ), MYCOLIACOL = INDXG2P( JA, NB, MYCOL, DESCA( CSRC_ ), NPCOL ), NBIACOL = INDXG2P( JA, NB, MYCOL, DESCA( CSRC_ ), NPCOL ), NPCOLIACOL = INDXG2P( JA, NB, MYCOL, DESCA( CSRC_ ), NPCOL ) |
| IAROW | <--- | INDXG2PIAROW = INDXG2P( IA, NB, MYROW, DESCA( RSRC_ ), NPROW ), MYROWIAROW = INDXG2P( IA, NB, MYROW, DESCA( RSRC_ ), NPROW ), NBIAROW = INDXG2P( IA, NB, MYROW, DESCA( RSRC_ ), NPROW ), NPROWIAROW = INDXG2P( IA, NB, MYROW, DESCA( RSRC_ ), NPROW ), RSRC_IAROW = INDXG2P( IA, NB, MYROW, DESCA( RSRC_ ), NPROW ), IAIAROW = INDXG2P( IA, NB, MYROW, DESCA( RSRC_ ), NPROW ) |
| ICOFFA | <--- | JAICOFFA = MOD( JA-1, DESCA( NB_ ) ), NB_ICOFFA = MOD( JA-1, DESCA( NB_ ) ) |
| ICOFFZ | <--- | JZICOFFZ = MOD( JZ-1, DESCZ( NB_ ) ), NB_ICOFFZ = MOD( JZ-1, DESCZ( NB_ ) ) |
| INDD | <--- | INDEINDD = INDE + N, NINDD = INDE + N |
| INDE | <--- | INDTAUINDE = INDTAU + N, NINDE = INDTAU + N |
| INDE2 | <--- | INDDINDE2 = INDD + N, NINDE2 = INDD + N |
| INDWORK | <--- | INDE2INDWORK = INDE2 + N, NINDWORK = INDE2 + N |
| INDWORK2 | <--- | INDDINDWORK2 = INDD |
| INFO | <--- | CSRC_INFO = -( 1200+CSRC_ ), M_INFO = -( 1200+M_ ), MB_INFO = -( 1200+MB_ ), CTXT_INFO = -( 1200+CTXT_ ){2INFO = -( 600+CTXT_ )}, NB_INFO = -( 700+NB_ ){2INFO = -( 1200+NB_ )}, RSRC_INFO = -( 1200+RSRC_ ) |
| IROFFA | <--- | MB_IROFFA = MOD( IA-1, DESCA( MB_ ) ), IAIROFFA = MOD( IA-1, DESCA( MB_ ) ) |
| IROFFZ | <--- | IZIROFFZ = MOD( IZ-1, DESCZ( MB_ ) ), MB_IROFFZ = MOD( IZ-1, DESCZ( MB_ ) ) |
| IWORK | <--- | LIWMINIWORK( 1 ) = LIWMIN |
| LIWMIN | <--- | NLIWMIN = 7*N + 8*NPCOL + 2, NPCOLLIWMIN = 7*N + 8*NPCOL + 2 |
| LLWORK | <--- | INDWORKLLWORK = LWORK - INDWORK + 1, LWORKLLWORK = LWORK - INDWORK + 1 |
| LLWORK2 | <--- | INDWORK2LLWORK2 = LWORK - INDWORK2 + 1, LWORKLLWORK2 = LWORK - INDWORK2 + 1 |
| LWMIN | <--- | NLWMIN = MAX( 1+6*N+2*NP*NQ, TRILWMIN ) + 2*N, NPLWMIN = MAX( 1+6*N+2*NP*NQ, TRILWMIN ) + 2*N, NQLWMIN = MAX( 1+6*N+2*NP*NQ, TRILWMIN ) + 2*N, TRILWMINLWMIN = MAX( 1+6*N+2*NP*NQ, TRILWMIN ) + 2*N |
| NB | <--- | NB_NB = DESCA( NB_ ) |
| NP | <--- | IAROWNP = NUMROC( N, NB, MYROW, IAROW, NPROW ), MYROWNP = NUMROC( N, NB, MYROW, IAROW, NPROW ), NNP = NUMROC( N, NB, MYROW, IAROW, NPROW ), NBNP = NUMROC( N, NB, MYROW, IAROW, NPROW ), NPROWNP = NUMROC( N, NB, MYROW, IAROW, NPROW ), NUMROCNP = NUMROC( N, NB, MYROW, IAROW, NPROW ) |
| NQ | <--- | IACOLNQ = NUMROC( N, NB, MYCOL, IACOL, NPCOL ), MYCOLNQ = NUMROC( N, NB, MYCOL, IACOL, NPCOL ), NNQ = NUMROC( N, NB, MYCOL, IACOL, NPCOL ), NBNQ = NUMROC( N, NB, MYCOL, IACOL, NPCOL ), NPCOLNQ = NUMROC( N, NB, MYCOL, IACOL, NPCOL ), NUMROCNQ = NUMROC( N, NB, MYCOL, IACOL, NPCOL ) |
| RMAX | <--- | BIGNUMRMAX = MIN( SQRT( BIGNUM ), ONE / SQRT( SQRT( SAFMIN ) ) ), ONERMAX = MIN( SQRT( BIGNUM ), ONE / SQRT( SQRT( SAFMIN ) ) ), SAFMINRMAX = MIN( SQRT( BIGNUM ), ONE / SQRT( SQRT( SAFMIN ) ) ) |
| RMIN | <--- | SMLNUMRMIN = SQRT( SMLNUM ) |
| SAFMIN | <--- | CTXT_SAFMIN = PDLAMCH( DESCA( CTXT_ ), 'Safe minimum' ), PDLAMCHSAFMIN = PDLAMCH( DESCA( CTXT_ ), 'Safe minimum' ) |
| SIGMA | <--- | ANRMSIGMA = RMIN / ANRM{2SIGMA = RMAX / ANRM}, RMAXSIGMA = RMAX / ANRM, RMINSIGMA = RMIN / ANRM |
| SMLNUM | <--- | SAFMINSMLNUM = SAFMIN / EPS, EPSSMLNUM = SAFMIN / EPS |
| TRILWMIN | <--- | NTRILWMIN = 3*N + MAX( NB*( NP+1 ), 3*NB ), NBTRILWMIN = 3*N + MAX( NB*( NP+1 ), 3*NB ), NPTRILWMIN = 3*N + MAX( NB*( NP+1 ), 3*NB ) |
| UPPER | <--- | LSAMEUPPER = LSAME( UPLO, 'U' ), UPLOUPPER = LSAME( UPLO, 'U' ) |
| WORK | <--- | LWMINWORK( 1 ) = DBLE( LWMIN ) |
|
|
Analysis elements of the routine PDSYEVD()
Put the mouse over each element to display detailed matching information
 Assigned variables |
| | | ANRM , BIGNUM , BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ , EPS , IACOL , IAROW , ICOFFA , ICOFFZ , IDUM1 , IDUM2 , INDD , INDE , INDE2 , INDTAU , INDWORK , INDWORK2 , INFO , IROFFA , IROFFZ , ISCALE , IWORK , LIWMIN , LLD_ , LLWORK , LLWORK2 , LQUERY , LWMIN , M_ , MB_ , N_ , NB , NB_ , NP , NQ , OFFSET , ONE , RMAX , RMIN , RSRC_ , SAFMIN , SIGMA , SMLNUM , TRILWMIN , UPPER , WORK , ZERO |
|
| Active variables |
| | | A , ANRM , BIGNUM , BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DESCA , DESCZ , DLEN_ , DTYPE_ , EPS , IA , IACOL , IAROW , ICOFFA , ICOFFZ , ICTXT , IDUM1 , IDUM2 , IINFO , INDD , INDE , INDE2 , INDTAU , INDWORK , INDWORK2 , INDXG2P , INFO , IROFFA , IROFFZ , ISCALE , IWORK , IZ , JA , JOBZ , JZ , LIWMIN , LIWORK , LLD_ , LLWORK , LLWORK2 , LQUERY , LSAME , LWMIN , LWORK , M_ , MB_ , MYCOL , MYROW , N , N_ , NB , NB_ , NP , NPCOL , NPROW , NQ , NUMROC , OFFSET , ONE , PDLAMCH , PDLANSY , RMAX , RMIN , RSRC_ , SAFMIN , SIGMA , SMLNUM , TRILWMIN , UPLO , UPPER , W , WORK , Z , ZERO |
|
| Accessed arrays [ array name : associated index ] |
| |  DESCA | : CSRC_ , CSRC_ , CTXT_ , CTXT_ , CTXT_ , M_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , RSRC_ , RSRC_ |
| | DESCZ | : CSRC_ , CTXT_ , CTXT_ , M_ , MB_ , MB_ , MB_ , NB_ , NB_ , RSRC_ |
| | IDUM1 | : 1 , 1 , 2 , 2 , 2 |
| | IDUM2 | : 1 , 2 , 2 |
| | INDXG2P | : IA, NB, MYROW, DESCA( RSRC_ ), NPROW , JA, NB, MYCOL, DESCA( CSRC_ ), NPCOL |
| | IWORK | : 1 |
| | LSAME | : JOBZ, 'V' , UPLO, 'L' , UPLO, 'U' |
| | NUMROC | : N, NB, MYCOL, IACOL, NPCOL , N, NB, MYROW, IAROW, NPROW |
| | PDLAMCH | : DESCA( CTXT_ ), 'Precision' , DESCA( CTXT_ ), 'Safe minimum' |
| | PDLANSY | : 'M', UPLO, N, A, IA, JA, DESCA, WORK( INDWORK ) |
| | WORK | : 1 , INDD , INDD , INDE , INDE+OFFSET , INDE2 , INDE2 , INDTAU , INDTAU , INDWORK , INDWORK , INDWORK , INDWORK , INDWORK2 , INDWORK2 |
|
| Conditional statements [ statement : associated predicate ] |
| | if | : ( BLOCK_CYCLIC_2D*CSRC_*CTXT_*DLEN_*DTYPE_*LLD_*MB_*M_*NB_*N_* ) , ( N.EQ.0 ) , ( NPROW.EQ. - 1 ) , ( INFO.EQ.0 ) , ( (.NOT.LSAME( JOBZ , 'V' ) ) ) , ( (.NOT.UPPER .AND. .NOT.LSAME( UPLO , 'L' ) ) ) , ( IROFFA.NE.ICOFFA .OR. ICOFFA.NE.0 ) , ( IROFFA.NE.IROFFZ .OR. ICOFFA.NE.ICOFFZ ) , ( (DESCA( M_ ).NE.DESCZ( M_ ) ) ) , ( (DESCA( MB_ ).NE.DESCA( NB_ ) ) ) , ( (DESCZ( MB_ ).NE.DESCZ( NB_ ) ) ) , ( (DESCA( MB_ ).NE.DESCZ( MB_ ) ) ) , ( (DESCA( CTXT_ ).NE.DESCZ( CTXT_ ) ) ) , ( (DESCA( RSRC_ ).NE.DESCZ( RSRC_ ) ) ) , ( (DESCA( CSRC_ ).NE.DESCZ( CSRC_ ) ) ) , ( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) , ( LIWORK.LT.LIWMIN .AND. .NOT.LQUERY ) , ( UPPER ) , ( LWORK.EQ. - 1 ) , ( INFO.NE.0 ) , ( LQUERY ) , ( necessary. ) , ( ANRM.GT.ZERO .AND. ANRM.LT.RMIN ) , ( ANRM.GT.RMAX ) , ( ISCALE.EQ.1 ) , ( UPPER ) , ( matrix was scaled , ) , ( ISCALE.EQ.1 ) |
|
| List of variables |
ANRM
BIGNUM
BLOCK_CYCLIC_2D
CSRC_
CTXT_
DLEN_
DTYPE_
| EPS
IA
IACOL
IAROW
ICOFFA
ICOFFZ
ICTXT
IDUM1( 2 )
| IDUM2( 2 )
IINFO
INDD
INDE
INDE2
INDTAU
INDWORK
INDWORK2
| INDXG2P
INFO
IROFFA
IROFFZ
ISCALE
IWORK
IZ
JA
| JOBZ
JZ
LIWMIN
LIWORK
LLD_
LLWORK
LLWORK2
LQUERY
| LSAME
LWMIN
LWORK
M_
MB_
MYCOL
MYROW
N
| N_
NB
NB_
NP
NPCOL
NPROW
NQ
NUMROC
| OFFSET
ONE
PDLAMCH
PDLANSY
RMAX
RMIN
RSRC_
SAFMIN
| SIGMA
SMLNUM
TRILWMIN
UPLO
UPPER
WORK
ZERO | | close
| |
ANRM
BIGNUM
BLOCK_CYCLIC_2D
CSRC_
CTXT_
DLEN_
DTYPE_
EPS
IA
IACOL
IAROW
ICOFFA
ICOFFZ
ICTXT
IDUM1( 2 )
IDUM2( 2 )
IINFO
INDD
INDE
INDE2
INDTAU
INDWORK
INDWORK2
INDXG2P
INFO
IROFFA
IROFFZ
ISCALE
IWORK
IZ
JA
JOBZ
JZ
LIWMIN
LIWORK
LLD_
LLWORK
LLWORK2
LQUERY
LSAME
LWMIN
LWORK
M_
MB_
MYCOL
MYROW
N
N_
NB
NB_
NP
NPCOL
NPROW
NQ
NUMROC
OFFSET
ONE
PDLAMCH
PDLANSY
RMAX
RMIN
RSRC_
SAFMIN
SIGMA
SMLNUM
TRILWMIN
UPLO
UPPER
WORK
ZERO
223#219#239#304#230#241#293#273
| |
