OpenRadioss 2025.1.11
OpenRadioss project
Loading...
Searching...
No Matches
pzgebdrv.f File Reference

Go to the source code of this file.

Functions/Subroutines

subroutine pzgebdrv (m, n, a, ia, ja, desca, d, e, tauq, taup, work, info)

Function/Subroutine Documentation

◆ pzgebdrv()

subroutine pzgebdrv ( integer m,
integer n,
complex*16, dimension( * ) a,
integer ia,
integer ja,
integer, dimension( * ) desca,
double precision, dimension( * ) d,
double precision, dimension( * ) e,
complex*16, dimension( * ) tauq,
complex*16, dimension( * ) taup,
complex*16, dimension( * ) work,
integer info )

Definition at line 1 of file pzgebdrv.f.

3*
4* -- ScaLAPACK routine (version 1.7) --
5* University of Tennessee, Knoxville, Oak Ridge National Laboratory,
6* and University of California, Berkeley.
7* May 1, 1997
8*
9* .. Scalar Arguments ..
10 INTEGER INFO, IA, JA, M, N
11* ..
12* .. Array Arguments ..
13 INTEGER DESCA( * )
14 DOUBLE PRECISION D( * ), E( * )
15 COMPLEX*16 A( * ), TAUP( * ), TAUQ( * ), WORK( * )
16* ..
17*
18* Purpose
19* =======
20*
21* PZGEBDRV computes sub( A ) = A(IA:IA+M-1,JA:JA+N-1) from sub( A ),
22* Q, P returned by PZGEBRD:
23*
24* sub( A ) := Q * B * P'.
25*
26* Notes
27* =====
28*
29* Each global data object is described by an associated description
30* vector. This vector stores the information required to establish
31* the mapping between an object element and its corresponding process
32* and memory location.
33*
34* Let A be a generic term for any 2D block cyclicly distributed array.
35* Such a global array has an associated description vector DESCA.
36* In the following comments, the character _ should be read as
37* "of the global array".
38*
39* NOTATION STORED IN EXPLANATION
40* --------------- -------------- --------------------------------------
41* DTYPE_A(global) DESCA( DTYPE_ )The descriptor type. In this case,
42* DTYPE_A = 1.
43* CTXT_A (global) DESCA( CTXT_ ) The BLACS context handle, indicating
44* the BLACS process grid A is distribu-
45* ted over. The context itself is glo-
46* bal, but the handle (the integer
47* value) may vary.
48* M_A (global) DESCA( M_ ) The number of rows in the global
49* array A.
50* N_A (global) DESCA( N_ ) The number of columns in the global
51* array A.
52* MB_A (global) DESCA( MB_ ) The blocking factor used to distribute
53* the rows of the array.
54* NB_A (global) DESCA( NB_ ) The blocking factor used to distribute
55* the columns of the array.
56* RSRC_A (global) DESCA( RSRC_ ) The process row over which the first
57* row of the array A is distributed.
58* CSRC_A (global) DESCA( CSRC_ ) The process column over which the
59* first column of the array A is
60* distributed.
61* LLD_A (local) DESCA( LLD_ ) The leading dimension of the local
62* array. LLD_A >= MAX(1,LOCr(M_A)).
63*
64* Let K be the number of rows or columns of a distributed matrix,
65* and assume that its process grid has dimension p x q.
66* LOCr( K ) denotes the number of elements of K that a process
67* would receive if K were distributed over the p processes of its
68* process column.
69* Similarly, LOCc( K ) denotes the number of elements of K that a
70* process would receive if K were distributed over the q processes of
71* its process row.
72* The values of LOCr() and LOCc() may be determined via a call to the
73* ScaLAPACK tool function, NUMROC:
74* LOCr( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
75* LOCc( N ) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).
76* An upper bound for these quantities may be computed by:
77* LOCr( M ) <= ceil( ceil(M/MB_A)/NPROW )*MB_A
78* LOCc( N ) <= ceil( ceil(N/NB_A)/NPCOL )*NB_A
79*
80* Arguments
81* =========
82*
83* M (global input) INTEGER
84* The number of rows to be operated on, i.e. the number of rows
85* of the distributed submatrix sub( A ). M >= 0.
86*
87* N (global input) INTEGER
88* The number of columns to be operated on, i.e. the number of
89* columns of the distributed submatrix sub( A ). N >= 0.
90*
91* A (local input/local output) COMPLEX*16 pointer into the
92* local memory to an array of dimension (LLD_A, LOCc(JA+N-1)).
93* On entry, this array contains the local pieces of sub( A )
94* as returned by PZGEBRD. On exit, the original distribu-
95* ted matrix sub( A ) is restored.
96*
97* IA (global input) INTEGER
98* The row index in the global array A indicating the first
99* row of sub( A ).
100*
101* JA (global input) INTEGER
102* The column index in the global array A indicating the
103* first column of sub( A ).
104*
105* DESCA (global and local input) INTEGER array of dimension DLEN_.
106* The array descriptor for the distributed matrix A.
107*
108* D (local input) DOUBLE PRECISION array, dimension
109* LOCc(JA+MIN(M,N)-1) if M >= N; LOCr(IA+MIN(M,N)-1) otherwise.
110* The distributed diagonal elements of the bidiagonal matrix
111* B: D(i) = A(i,i). D is tied to the distributed matrix A.
112*
113* E (local input) DOUBLE PRECISION array, dimension
114* LOCr(IA+MIN(M,N)-1) if M >= N; LOCc(JA+MIN(M,N)-2) otherwise.
115* The distributed off-diagonal elements of the bidiagonal
116* distributed matrix B:
117* if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;
118* if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1.
119* E is tied to the distributed matrix A.
120*
121* TAUQ (local input) COMPLEX*16 array dimension
122* LOCc(JA+MIN(M,N)-1). The scalar factors of the elementary
123* reflectors which represent the unitary matrix Q. TAUQ is
124* tied to the distributed matrix A. See Further Details.
125*
126* TAUP (local input) COMPLEX*16 array, dimension
127* LOCr(IA+MIN(M,N)-1). The scalar factors of the elementary
128* reflectors which represent the unitary matrix P. TAUP is
129* tied to the distributed matrix A. See Further Details.
130*
131* WORK (local workspace) COMPLEX*16 array, dimension (LWORK)
132* LWORK >= 2*NB*( MP + NQ + NB )
133*
134* where NB = MB_A = NB_A,
135* IROFFA = MOD( IA-1, NB ), ICOFFA = MOD( JA-1, NB ),
136* IAROW = INDXG2P( IA, NB, MYROW, RSRC_A, NPROW ),
137* IACOL = INDXG2P( JA, NB, MYCOL, CSRC_A, NPCOL ),
138* MP = NUMROC( M+IROFFA, NB, MYROW, IAROW, NPROW ),
139* NQ = NUMROC( N+ICOFFA, NB, MYCOL, IACOL, NPCOL ).
140*
141* INDXG2P and NUMROC are ScaLAPACK tool functions;
142* MYROW, MYCOL, NPROW and NPCOL can be determined by calling
143* the subroutine BLACS_GRIDINFO.
144*
145* INFO (global output) INTEGER
146* On exit, if INFO <> 0, a discrepancy has been found between
147* the diagonal and off-diagonal elements of A and the copies
148* contained in the arrays D and E.
149*
150* =====================================================================
151*
152* .. Parameters ..
153 INTEGER BLOCK_CYCLIC_2D, CSRC_, CTXT_, DLEN_, DTYPE_,
154 $ LLD_, MB_, M_, NB_, N_, RSRC_
155 parameter( block_cyclic_2d = 1, dlen_ = 9, dtype_ = 1,
156 $ ctxt_ = 2, m_ = 3, n_ = 4, mb_ = 5, nb_ = 6,
157 $ rsrc_ = 7, csrc_ = 8, lld_ = 9 )
158 DOUBLE PRECISION REIGHT, RZERO
159 parameter( reight = 8.0d+0, rzero = 0.0d+0 )
160 COMPLEX*16 ONE, ZERO
161 parameter( one = ( 1.0d+0, 0.0d+0 ),
162 $ zero = ( 0.0d+0, 0.0d+0 ) )
163* ..
164* .. Local Scalars ..
165 INTEGER I, IACOL, IAROW, ICTXT, IIA, IL, IPTP, IPTQ,
166 $ IPV, IPW, IPWK, IOFF, IV, J, JB, JJA, JL, JV,
167 $ K, MN, MP, MYCOL, MYROW, NB, NPCOL, NPROW, NQ
168 DOUBLE PRECISION ADDBND, D2, E2
169 COMPLEX*16 D1, E1
170* ..
171* .. Local Arrays ..
172 INTEGER DESCD( DLEN_ ), DESCE( DLEN_ ), DESCV( DLEN_ ),
173 $ DESCW( DLEN_ )
174* ..
175* .. External Subroutines ..
176 EXTERNAL blacs_gridinfo, descset, igsum2d, infog2l,
177 $ pdelget, pzlacpy, pzlarfb, pzlarft,
178 $ pzlaset, pzelget
179* ..
180* .. External Functions ..
181 INTEGER INDXG2P, NUMROC
182 DOUBLE PRECISION PDLAMCH
183 EXTERNAL indxg2p, numroc, pdlamch
184* ..
185* .. Intrinsic Functions ..
186 INTRINSIC abs, dcmplx, max, min, mod
187* ..
188* .. Executable Statements ..
189*
190* Get grid parameters
191*
192 ictxt = desca( ctxt_ )
193 CALL blacs_gridinfo( ictxt, nprow, npcol, myrow, mycol )
194*
195 info = 0
196 nb = desca( mb_ )
197 ioff = mod( ia-1, nb )
198 CALL infog2l( ia, ja, desca, nprow, npcol, myrow, mycol, iia, jja,
199 $ iarow, iacol )
200 mp = numroc( m+ioff, nb, myrow, iarow, nprow )
201 nq = numroc( n+ioff, nb, mycol, iacol, npcol )
202 ipv = 1
203 ipw = ipv + mp*nb
204 iptp = ipw + nq*nb
205 iptq = iptp + nb*nb
206 ipwk = iptq + nb*nb
207*
208 iv = 1
209 jv = 1
210 mn = min( m, n )
211 il = max( ( (ia+mn-2) / nb )*nb + 1, ia )
212 jl = max( ( (ja+mn-2) / nb )*nb + 1, ja )
213 iarow = indxg2p( il, nb, myrow, desca( rsrc_ ), nprow )
214 iacol = indxg2p( jl, nb, mycol, desca( csrc_ ), npcol )
215 CALL descset( descv, ia+m-il, nb, nb, nb, iarow, iacol, ictxt,
216 $ max( 1, mp ) )
217 CALL descset( descw, nb, ja+n-jl, nb, nb, iarow, iacol, ictxt,
218 $ nb )
219*
220 addbnd = reight * pdlamch( ictxt, 'eps' )
221*
222* When A is an upper bidiagonal form
223*
224 IF( m.GE.n ) THEN
225*
226 CALL descset( descd, 1, ja+mn-1, 1, desca( nb_ ), myrow,
227 $ desca( csrc_ ), desca( ctxt_ ), 1 )
228 CALL descset( desce, ia+mn-1, 1, desca( mb_ ), 1,
229 $ desca( rsrc_ ), mycol, desca( ctxt_ ),
230 $ desca( lld_ ) )
231*
232 DO 10 j = 0, mn-1
233 d1 = zero
234 e1 = zero
235 d2 = rzero
236 e2 = rzero
237 CALL pdelget( ' ', ' ', d2, d, 1, ja+j, descd )
238 CALL pzelget( 'Columnwise', ' ', d1, a, ia+j, ja+j, desca )
239 IF( j.LT.(mn-1) ) THEN
240 CALL pdelget( ' ', ' ', E2, E, IA+J, 1, DESCE )
241 CALL PZELGET( 'rowwise', ' ', E1, A, IA+J, JA+J+1,
242 $ DESCA )
243 END IF
244*
245.GT..OR. IF( ( ABS( D1-DCMPLX( D2 ) )( ABS( D2 )*ADDBND ) )
246.GT. $ ( ABS( E1-DCMPLX( E2 ) )( ABS( E2 )*ADDBND ) ) )
247 $ INFO = INFO + 1
248 10 CONTINUE
249*
250 DO 20 J = JL, JA+NB-IOFF, -NB
251 JB = MIN( JA+N-J, NB )
252 I = IA + J - JA
253 K = I - IA + 1
254*
255* Compute upper triangular matrix TQ from TAUQ.
256*
257 CALL PZLARFT( 'forward', 'columnwise', M-K+1, JB, A, I, J,
258 $ DESCA, TAUQ, WORK( IPTQ ), WORK( IPWK ) )
259*
260* Copy Householder vectors into workspace.
261*
262 CALL PZLACPY( 'lower', M-K+1, JB, A, I, J, DESCA,
263 $ WORK( IPV ), IV, JV, DESCV )
264 CALL PZLASET( 'upper', M-K+1, JB, ZERO, ONE, WORK( IPV ),
265 $ IV, JV, DESCV )
266*
267* Zero out the strict lower triangular part of A.
268*
269 CALL PZLASET( 'lower', M-K, JB, ZERO, ZERO, A, I+1, J,
270 $ DESCA )
271*
272* Compute upper triangular matrix TP from TAUP.
273*
274 CALL PZLARFT( 'forward', 'rowwise', N-K, JB, A, I, J+1,
275 $ DESCA, TAUP, WORK( IPTP ), WORK( IPWK ) )
276*
277* Copy Householder vectors into workspace.
278*
279 CALL PZLACPY( 'upper', JB, N-K, A, I, J+1, DESCA,
280 $ WORK( IPW ), IV, JV+1, DESCW )
281 CALL PZLASET( 'lower', JB, N-K, ZERO, ONE, WORK( IPW ), IV,
282 $ JV+1, DESCW )
283*
284* Zero out the strict+1 upper triangular part of A.
285*
286 CALL PZLASET( 'upper', JB, N-K-1, ZERO, ZERO, A, I, J+2,
287 $ DESCA )
288*
289* Apply block Householder transformation from Left.
290*
291 CALL PZLARFB( 'left', 'no transpose', 'forward',
292 $ 'columnwise', M-K+1, N-K+1, JB, WORK( IPV ),
293 $ IV, JV, DESCV, WORK( IPTQ ), A, I, J, DESCA,
294 $ WORK( IPWK ) )
295*
296* Apply block Householder transformation from Right.
297*
298 CALL PZLARFB( 'right', 'conjugate transpose', 'forward',
299 $ 'rowwise', M-K+1, N-K, JB, WORK( IPW ), IV,
300 $ JV+1, DESCW, WORK( IPTP ), A, I, J+1, DESCA,
301 $ WORK( IPWK ) )
302*
303 DESCV( M_ ) = DESCV( M_ ) + NB
304 DESCV( RSRC_ ) = MOD( DESCV( RSRC_ ) + NPROW - 1, NPROW )
305 DESCV( CSRC_ ) = MOD( DESCV( CSRC_ ) + NPCOL - 1, NPCOL )
306 DESCW( N_ ) = DESCW( N_ ) + NB
307 DESCW( RSRC_ ) = DESCV( RSRC_ )
308 DESCW( CSRC_ ) = DESCV( CSRC_ )
309*
310 20 CONTINUE
311*
312* Handle first block separately
313*
314 JB = MIN( N, NB - IOFF )
315 IV = IOFF + 1
316 JV = IOFF + 1
317*
318* Compute upper triangular matrix TQ from TAUQ.
319*
320 CALL PZLARFT( 'forward', 'columnwise', M, JB, A, IA, JA, DESCA,
321 $ TAUQ, WORK( IPTQ ), WORK( IPWK ) )
322*
323* Copy Householder vectors into workspace.
324*
325 CALL PZLACPY( 'lower', M, JB, A, IA, JA, DESCA, WORK( IPV ),
326 $ IV, JV, DESCV )
327 CALL PZLASET( 'upper', M, JB, ZERO, ONE, WORK( IPV ), IV, JV,
328 $ DESCV )
329*
330* Zero out the strict lower triangular part of A.
331*
332 CALL PZLASET( 'lower', M-1, JB, ZERO, ZERO, A, IA+1, JA,
333 $ DESCA )
334*
335* Compute upper triangular matrix TP from TAUP.
336*
337 CALL PZLARFT( 'forward', 'rowwise', N-1, JB, A, IA, JA+1,
338 $ DESCA, TAUP, WORK( IPTP ), WORK( IPWK ) )
339*
340* Copy Householder vectors into workspace.
341*
342 CALL PZLACPY( 'upper', JB, N-1, A, IA, JA+1, DESCA,
343 $ WORK( IPW ), IV, JV+1, DESCW )
344 CALL PZLASET( 'lower', JB, N-1, ZERO, ONE, WORK( IPW ), IV,
345 $ JV+1, DESCW )
346*
347* Zero out the strict+1 upper triangular part of A.
348*
349 CALL PZLASET( 'upper', JB, N-2, ZERO, ZERO, A, IA, JA+2,
350 $ DESCA )
351*
352* Apply block Householder transformation from left.
353*
354 CALL PZLARFB( 'left', 'no transpose', 'forward', 'columnwise',
355 $ M, N, JB, WORK( IPV ), IV, JV, DESCV,
356 $ WORK( IPTQ ), A, IA, JA, DESCA, WORK( IPWK ) )
357*
358* Apply block Householder transformation from right.
359*
360 CALL PZLARFB( 'right', 'conjugate transpose', 'forward',
361 $ 'rowwise', M, N-1, JB, WORK( IPW ), IV, JV+1,
362 $ DESCW, WORK( IPTP ), A, IA, JA+1, DESCA,
363 $ WORK( IPWK ) )
364*
365 ELSE
366*
367 CALL DESCSET( DESCD, IA+MN-1, 1, DESCA( MB_ ), 1,
368 $ DESCA( RSRC_ ), MYCOL, DESCA( CTXT_ ),
369 $ DESCA( LLD_ ) )
370 CALL DESCSET( DESCE, 1, JA+MN-2, 1, DESCA( NB_ ), MYROW,
371 $ DESCA( CSRC_ ), DESCA( CTXT_ ), 1 )
372*
373 DO 30 J = 0, MN-1
374 D1 = ZERO
375 E1 = ZERO
376 D2 = RZERO
377 E2 = RZERO
378 CALL PDELGET( ' ', ' ', D2, D, IA+J, 1, DESCD )
379 CALL PZELGET( 'rowwise', ' ', D1, A, IA+J, JA+J, DESCA )
380.LT. IF( J(MN-1) ) THEN
381 CALL PDELGET( ' ', ' ', E2, E, 1, JA+J, DESCE )
382 CALL PZELGET( 'columnwise', ' ', E1, A, IA+J+1, JA+J,
383 $ DESCA )
384 END IF
385*
386.GT..OR. IF( ( ABS( D1-DCMPLX( D2 ) )( ABS( D2 )*ADDBND ) )
387.GT. $ ( ABS( E1-DCMPLX( E2 ) )( ABS( E2 )*ADDBND ) ) )
388 $ INFO = INFO + 1
389 30 CONTINUE
390*
391 DO 40 I = IL, IA+NB-IOFF, -NB
392 JB = MIN( IA+M-I, NB )
393 J = JA + I - IA
394 K = J - JA + 1
395*
396* Compute upper triangular matrix TQ from TAUQ.
397*
398 CALL PZLARFT( 'forward', 'columnwise', M-K, JB, A, I+1, J,
399 $ DESCA, TAUQ, WORK( IPTQ ), WORK( IPWK ) )
400*
401* Copy Householder vectors into workspace.
402*
403 CALL PZLACPY( 'lower', M-K, JB, A, I+1, J, DESCA,
404 $ WORK( IPV ), IV+1, JV, DESCV )
405 CALL PZLASET( 'upper', M-K, JB, ZERO, ONE, WORK( IPV ),
406 $ IV+1, JV, DESCV )
407*
408* Zero out the strict lower triangular part of A.
409*
410 CALL PZLASET( 'lower', M-K-1, JB, ZERO, ZERO, A, I+2, J,
411 $ DESCA )
412*
413* Compute upper triangular matrix TP from TAUP.
414*
415 CALL PZLARFT( 'forward', 'rowwise', N-K+1, JB, A, I, J,
416 $ DESCA, TAUP, WORK( IPTP ), WORK( IPWK ) )
417*
418* Copy Householder vectors into workspace.
419*
420 CALL PZLACPY( 'upper', JB, N-K+1, A, I, J, DESCA,
421 $ WORK( IPW ), IV, JV, DESCW )
422 CALL PZLASET( 'lower', JB, N-K+1, ZERO, ONE, WORK( IPW ),
423 $ IV, JV, DESCW )
424*
425* Zero out the strict+1 upper triangular part of A.
426*
427 CALL PZLASET( 'upper', JB, N-K, ZERO, ZERO, A, I, J+1,
428 $ DESCA )
429*
430* Apply block Householder transformation from Left.
431*
432 CALL PZLARFB( 'left', 'no transpose', 'forward',
433 $ 'columnwise', M-K, N-K+1, JB, WORK( IPV ),
434 $ IV+1, JV, DESCV, WORK( IPTQ ), A, I+1, J,
435 $ DESCA, WORK( IPWK ) )
436*
437* Apply block Householder transformation from Right.
438*
439 CALL PZLARFB( 'right', 'conjugate transpose', 'forward',
440 $ 'rowwise', M-K+1, N-K+1, JB, WORK( IPW ), IV,
441 $ JV, DESCW, WORK( IPTP ), A, I, J, DESCA,
442 $ WORK( IPWK ) )
443*
444 DESCV( M_ ) = DESCV( M_ ) + NB
445 DESCV( RSRC_ ) = MOD( DESCV( RSRC_ ) + NPROW - 1, NPROW )
446 DESCV( CSRC_ ) = MOD( DESCV( CSRC_ ) + NPCOL - 1, NPCOL )
447 DESCW( N_ ) = DESCW( N_ ) + NB
448 DESCW( RSRC_ ) = DESCV( RSRC_ )
449 DESCW( CSRC_ ) = DESCV( CSRC_ )
450*
451 40 CONTINUE
452*
453* Handle first block separately
454*
455 JB = MIN( M, NB - IOFF )
456 IV = IOFF + 1
457 JV = IOFF + 1
458*
459* Compute upper triangular matrix TQ from TAUQ.
460*
461 CALL PZLARFT( 'forward', 'columnwise', M-1, JB, A, IA+1, JA,
462 $ DESCA, TAUQ, WORK( IPTQ ), WORK( IPWK ) )
463*
464* Copy Householder vectors into workspace.
465*
466 CALL PZLACPY( 'lower', M-1, JB, A, IA+1, JA, DESCA,
467 $ WORK( IPV ), IV+1, JV, DESCV )
468 CALL PZLASET( 'upper', M-1, JB, ZERO, ONE, WORK( IPV ), IV+1,
469 $ JV, DESCV )
470*
471* Zero out the strict lower triangular part of A.
472*
473 CALL PZLASET( 'lower', M-2, JB, ZERO, ZERO, A, IA+2, JA,
474 $ DESCA )
475*
476* Compute upper triangular matrix TP from TAUP.
477*
478 CALL PZLARFT( 'forward', 'rowwise', N, JB, A, IA, JA, DESCA,
479 $ TAUP, WORK( IPTP ), WORK( IPWK ) )
480*
481* Copy Householder vectors into workspace.
482*
483 CALL PZLACPY( 'upper', JB, N, A, IA, JA, DESCA, WORK( IPW ),
484 $ IV, JV, DESCW )
485 CALL PZLASET( 'lower', JB, N, ZERO, ONE, WORK( IPW ), IV, JV,
486 $ DESCW )
487*
488* Zero out the strict+1 upper triangular part of A.
489*
490 CALL PZLASET( 'upper', JB, N-1, ZERO, ZERO, A, IA, JA+1,
491 $ DESCA )
492*
493* Apply block Householder transformation from left
494*
495 CALL PZLARFB( 'left', 'no transpose', 'forward', 'columnwise',
496 $ M-1, N, JB, WORK( IPV ), IV+1, JV, DESCV,
497 $ WORK( IPTQ ), A, IA+1, JA, DESCA, WORK( IPWK ) )
498*
499* Apply block Householder transformation from right
500*
501 CALL PZLARFB( 'right', 'conjugate transpose', 'forward',
502 $ 'rowwise', M, N, JB, WORK( IPW ), IV, JV, DESCW,
503 $ WORK( IPTP ), A, IA, JA, DESCA, WORK( IPWK ) )
504 END IF
505*
506 CALL IGSUM2D( ICTXT, 'all', ' ', 1, 1, INFO, 1, -1, 0 )
507*
508 RETURN
509*
510* End of PZGEBDRV
511*
min
#define min(a, b)
Definition macros.h:20
max
#define max(a, b)
Definition macros.h:21
indxg2p
integer function indxg2p(indxglob, nb, iproc, isrcproc, nprocs)
Definition mpi.f:947
descset
subroutine descset(desc, m, n, mb, nb, irsrc, icsrc, ictxt, lld)
Definition mpi.f:1610
infog2l
subroutine infog2l(grindx, gcindx, desc, nprow, npcol, myrow, mycol, lrindx, lcindx, rsrc, csrc)
Definition mpi.f:937
blacs_gridinfo
subroutine blacs_gridinfo(cntxt, nprow, npcol, myrow, mycol)
Definition mpi.f:754
numroc
integer function numroc(n, nb, iproc, isrcproc, nprocs)
Definition mpi.f:786
pdlamch
double precision function pdlamch(ictxt, cmach)
Definition pdblastst.f:6769
pdelget
subroutine pdelget(scope, top, alpha, a, ia, ja, desca)
Definition pdelget.f:2
pzlaset
subroutine pzlaset(uplo, m, n, alpha, beta, a, ia, ja, desca)
Definition pzblastst.f:7509
pzelget
subroutine pzelget(scope, top, alpha, a, ia, ja, desca)
Definition pzelget.f:2
pzlacpy
subroutine pzlacpy(uplo, m, n, a, ia, ja, desca, b, ib, jb, descb)
Definition pzlacpy.f:3
pzlarfb
subroutine pzlarfb(side, trans, direct, storev, m, n, k, v, iv, jv, descv, t, c, ic, jc, descc, work)
Definition pzlarfb.f:3
pzlarft
subroutine pzlarft(direct, storev, n, k, v, iv, jv, descv, tau, t, work)
Definition pzlarft.f:3