SCALAPACK 2.2.2
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches
pcpblaschk.f
Go to the documentation of this file.
1 SUBROUTINE pcpblaschk( SYMM, UPLO, N, BWL, BWU, NRHS, X, IX, JX,
2 $ DESCX, IASEED, A, IA, JA, DESCA, IBSEED,
3 $ ANORM, RESID, WORK, WORKSIZ )
4*
5*
6* -- ScaLAPACK routine (version 1.7) --
7* University of Tennessee, Knoxville, Oak Ridge National Laboratory,
8* and University of California, Berkeley.
9* November 15, 1997
10*
11* .. Scalar Arguments ..
12 CHARACTER SYMM, UPLO
13 INTEGER BWL, BWU, IA, IASEED, IBSEED,
14 $ ix, ja, jx, n, nrhs, worksiz
15 REAL ANORM, RESID
16* ..
17* .. Array Arguments ..
18 INTEGER DESCA( * ), DESCX( * )
19 COMPLEX A( * ), WORK( * ), X( * )
20* .. External Functions ..
21 LOGICAL LSAME
22* ..
23*
24* Purpose
25* =======
26*
27* PCPBLASCHK computes the residual
28* || sub( A )*sub( X ) - B || / (|| sub( A ) ||*|| sub( X ) ||*eps*N)
29* to check the accuracy of the factorization and solve steps in the
30* LU and Cholesky decompositions, where sub( A ) denotes
31* A(IA:IA+N-1,JA,JA+N-1), sub( X ) denotes X(IX:IX+N-1, JX:JX+NRHS-1).
32*
33* Notes
34* =====
35*
36* Each global data object is described by an associated description
37* vector. This vector stores the information required to establish
38* the mapping between an object element and its corresponding process
39* and memory location.
40*
41* Let A be a generic term for any 2D block cyclicly distributed array.
42* Such a global array has an associated description vector DESCA.
43* In the following comments, the character _ should be read as
44* "of the global array".
45*
46* NOTATION STORED IN EXPLANATION
47* --------------- -------------- --------------------------------------
48* DTYPE_A(global) DESCA( DTYPE_ )The descriptor type. In this case,
49* DTYPE_A = 1.
50* CTXT_A (global) DESCA( CTXT_ ) The BLACS context handle, indicating
51* the BLACS process grid A is distribu-
52* ted over. The context itself is glo-
53* bal, but the handle (the integer
54* value) may vary.
55* M_A (global) DESCA( M_ ) The number of rows in the global
56* array A.
57* N_A (global) DESCA( N_ ) The number of columns in the global
58* array A.
59* MB_A (global) DESCA( MB_ ) The blocking factor used to distribute
60* the rows of the array.
61* NB_A (global) DESCA( NB_ ) The blocking factor used to distribute
62* the columns of the array.
63* RSRC_A (global) DESCA( RSRC_ ) The process row over which the first
64* row of the array A is distributed.
65* CSRC_A (global) DESCA( CSRC_ ) The process column over which the
66* first column of the array A is
67* distributed.
68* LLD_A (local) DESCA( LLD_ ) The leading dimension of the local
69* array. LLD_A >= MAX(1,LOCr(M_A)).
70*
71* Let K be the number of rows or columns of a distributed matrix,
72* and assume that its process grid has dimension p x q.
73* LOCr( K ) denotes the number of elements of K that a process
74* would receive if K were distributed over the p processes of its
75* process column.
76* Similarly, LOCc( K ) denotes the number of elements of K that a
77* process would receive if K were distributed over the q processes of
78* its process row.
79* The values of LOCr() and LOCc() may be determined via a call to the
80* ScaLAPACK tool function, NUMROC:
81* LOCr( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
82* LOCc( N ) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).
83* An upper bound for these quantities may be computed by:
84* LOCr( M ) <= ceil( ceil(M/MB_A)/NPROW )*MB_A
85* LOCc( N ) <= ceil( ceil(N/NB_A)/NPCOL )*NB_A
86*
87* Arguments
88* =========
89*
90* SYMM (global input) CHARACTER
91* if SYMM = 'H', sub( A ) is a hermitian distributed band
92* matrix, otherwise sub( A ) is a general distributed matrix.
93*
94* UPLO (global input) CHARACTER
95* if SYMM = 'H', then
96* if UPLO = 'L', the lower half of the matrix is stored
97* if UPLO = 'U', the upper half of the matrix is stored
98* if SYMM != 'S' or 'H', then
99* if UPLO = 'D', the matrix is stable during factorization
100* without interchanges
101* if UPLO != 'D', the matrix is general
102*
103* N (global input) INTEGER
104* The number of columns to be operated on, i.e. the number of
105* columns of the distributed submatrix sub( A ). N >= 0.
106*
107* NRHS (global input) INTEGER
108* The number of right-hand-sides, i.e the number of columns
109* of the distributed matrix sub( X ). NRHS >= 1.
110*
111* X (local input) COMPLEX pointer into the local memory
112* to an array of dimension (LLD_X,LOCq(JX+NRHS-1). This array
113* contains the local pieces of the answer vector(s) sub( X ) of
114* sub( A ) sub( X ) - B, split up over a column of processes.
115*
116* IX (global input) INTEGER
117* The row index in the global array X indicating the first
118* row of sub( X ).
119*
120* DESCX (global and local input) INTEGER array of dimension DLEN_.
121* The array descriptor for the distributed matrix X.
122*
123* IASEED (global input) INTEGER
124* The seed number to generate the original matrix Ao.
125*
126* JA (global input) INTEGER
127* The column index in the global array A indicating the
128* first column of sub( A ).
129*
130* DESCA (global and local input) INTEGER array of dimension DLEN_.
131* The array descriptor for the distributed matrix A.
132*
133* IBSEED (global input) INTEGER
134* The seed number to generate the original matrix B.
135*
136* ANORM (global input) REAL
137* The 1-norm or infinity norm of the distributed matrix
138* sub( A ).
139*
140* RESID (global output) REAL
141* The residual error:
142* ||sub( A )*sub( X )-B|| / (||sub( A )||*||sub( X )||*eps*N).
143*
144* WORK (local workspace) COMPLEX array, dimension (LWORK)
145* IF SYMM='S'
146* LWORK >= max(5,max(bw*(bw+2),NB))+2*NB
147* IF SYMM!='S' or 'H'
148* LWORK >= max(5,max(bw*(bw+2),NB))+2*NB
149*
150* WORKSIZ (local input) size of WORK.
151*
152* =====================================================================
153*
154* Code Developer: Andrew J. Cleary, University of Tennessee.
155* Current address: Lawrence Livermore National Labs.
156* This version released: August, 2001.
157*
158* =====================================================================
159*
160* .. Parameters ..
161 COMPLEX ZERO, ONE
162 PARAMETER ( ONE = ( 1.0e+0, 0.0e+0 ),
163 $ zero = ( 0.0e+0, 0.0e+0 ) )
164 INTEGER BLOCK_CYCLIC_2D, CSRC_, CTXT_, DLEN_, DTYPE_,
165 $ LLD_, MB_, M_, NB_, N_, RSRC_
166 parameter( block_cyclic_2d = 1, dlen_ = 9, dtype_ = 1,
167 $ ctxt_ = 2, m_ = 3, n_ = 4, mb_ = 5, nb_ = 6,
168 $ rsrc_ = 7, csrc_ = 8, lld_ = 9 )
169 INTEGER INT_ONE
170 PARAMETER ( INT_ONE = 1 )
171* ..
172* .. Local Scalars ..
173 INTEGER IACOL, IAROW, ICTXT,
174 $ IIA, IIX, IPB, IPW,
175 $ ixcol, ixrow, j, jja, jjx, lda,
176 $ mycol, myrow, nb, np, npcol, nprow, nq
177 INTEGER BW, INFO, IPPRODUCT, WORK_MIN
178 REAL DIVISOR, EPS, RESID1, NORMX
179* ..
180* .. Local Arrays ..
181* ..
182* .. External Subroutines ..
183 EXTERNAL blacs_gridinfo, cgamx2d, cgemm, cgsum2d,
184 $ claset, pbctran, pcmatgen, sgebr2d,
185 $ sgebs2d, sgerv2d, sgesd2d
186* ..
187* .. External Functions ..
188 INTEGER ICAMAX, NUMROC
189 REAL PSLAMCH
190 EXTERNAL icamax, numroc, pslamch
191* ..
192* .. Intrinsic Functions ..
193 INTRINSIC abs, max, min, mod, real
194* ..
195* .. Executable Statements ..
196*
197* Get needed initial parameters
198*
199 ictxt = desca( ctxt_ )
200 nb = desca( nb_ )
201*
202 IF( lsame( symm, 'H' ) ) THEN
203 bw = bwl
204 work_min = max(5,max(bw*(bw+2),nb))+2*nb
205 ELSE
206 bw = max(bwl, bwu)
207 work_min = max(5,max(bw*(bw+2),nb))+2*nb
208 ENDIF
209*
210 IF ( worksiz .LT. work_min ) THEN
211 CALL pxerbla( ictxt, 'PCBLASCHK', -18 )
212 RETURN
213 END IF
214*
215 CALL blacs_gridinfo( ictxt, nprow, npcol, myrow, mycol )
216*
217 eps = pslamch( ictxt, 'eps' )
218 resid = 0.0e+0
219 divisor = anorm * eps * real( n )
220*
221 CALL infog2l( ia, ja, desca, nprow, npcol, myrow, mycol, iia, jja,
222 $ iarow, iacol )
223 CALL infog2l( ix, jx, descx, nprow, npcol, myrow, mycol, iix, jjx,
224 $ ixrow, ixcol )
225 np = numroc( (bw+1), desca( mb_ ), myrow, 0, nprow )
226 nq = numroc( n, desca( nb_ ), mycol, 0, npcol )
227*
228 ipb = 1
229 ipproduct = 1 + desca( nb_ )
230 ipw = 1 + 2*desca( nb_ )
231*
232 lda = desca( lld_ )
233*
234* Regenerate A
235*
236 IF( lsame( symm, 'H' )) THEN
237 CALL pcbmatgen( ictxt, uplo, 'D', bw, bw, n, bw+1,
238 $ desca( nb_ ), a, desca( lld_ ), 0, 0,
239 $ iaseed, myrow, mycol, nprow, npcol )
240 ELSE
241*
242 CALL pcbmatgen( ictxt, 'N', uplo, bwl, bwu, n,
243 $ desca( mb_ ), desca( nb_ ), a,
244 $ desca( lld_ ), 0, 0, iaseed, myrow,
245 $ mycol, nprow, npcol )
246 ENDIF
247*
248* Loop over the rhs
249*
250 resid = 0.0
251*
252 DO 40 j = 1, nrhs
253*
254* Multiply A * current column of X
255*
256*
257 CALL pcpbdcmv( bw+1, bw, uplo, n, a, 1, desca,
258 $ 1, x( 1 + (j-1)*descx( lld_ )), 1, descx,
259 $ work( ipproduct ), work( ipw ), (bw+2)*bw, info )
260*
261*
262* Regenerate column of B
263*
264 CALL pcmatgen( descx( ctxt_ ), 'No', 'No', descx( m_ ),
265 $ descx( n_ ), descx( mb_ ), descx( nb_ ),
266 $ work( ipb ), descx( lld_ ), descx( rsrc_ ),
267 $ descx( csrc_ ), ibseed, 0, nq, j-1, 1, mycol,
268 $ myrow, npcol, nprow )
269*
270* Figure || A * X - B || & || X ||
271*
272 CALL pcaxpy( n, -one, work( ipproduct ), 1, 1, descx, 1,
273 $ work( ipb ), 1, 1, descx, 1 )
274*
275 CALL pscnrm2( n, normx,
276 $ x, 1, j, descx, 1 )
277*
278 CALL pscnrm2( n, resid1,
279 $ work( ipb ), 1, 1, descx, 1 )
280*
281*
282* Calculate residual = ||Ax-b|| / (||x||*||A||*eps*N)
283*
284 resid1 = resid1 / ( normx*divisor )
285*
286 resid = max( resid, resid1 )
287*
288 40 CONTINUE
289*
290 RETURN
291*
292* End of PCBLASCHK
293*
294 END
subroutine pcmatgen(ictxt, aform, diag, m, n, mb, nb, a, lda, iarow, iacol, iseed, iroff, irnum, icoff, icnum, myrow, mycol, nprow, npcol)
Definition pcmatgen.f:4
subroutine infog2l(grindx, gcindx, desc, nprow, npcol, myrow, mycol, lrindx, lcindx, rsrc, csrc)
Definition infog2l.f:3
subroutine pbctran(icontxt, adist, trans, m, n, nb, a, lda, beta, c, ldc, iarow, iacol, icrow, iccol, work)
Definition pbctran.f:3
subroutine pcbmatgen(ictxt, aform, aform2, bwl, bwu, n, mb, nb, a, lda, iarow, iacol, iseed, myrow, mycol, nprow, npcol)
Definition pcbmatgen.f:5
#define max(A, B)
Definition pcgemr.c:180
#define min(A, B)
Definition pcgemr.c:181
subroutine pcpblaschk(symm, uplo, n, bwl, bwu, nrhs, x, ix, jx, descx, iaseed, a, ia, ja, desca, ibseed, anorm, resid, work, worksiz)
Definition pcpblaschk.f:4
subroutine pcpbdcmv(ldbw, bw, uplo, n, a, ja, desca, nrhs, b, ib, descb, x, work, lwork, info)
Definition pcpbmv1.f:3
subroutine pxerbla(ictxt, srname, info)
Definition pxerbla.f:2