ScaLAPACK 2.1  2.1
ScaLAPACK: Scalable Linear Algebra PACKage
pssyntrd.f
Go to the documentation of this file.
1  SUBROUTINE pssyntrd( UPLO, N, A, IA, JA, DESCA, D, E, TAU, WORK,
2  $ LWORK, INFO )
3 *
4 * -- ScaLAPACK routine (version 1.7) --
5 * University of Tennessee, Knoxville, Oak Ridge National Laboratory,
6 * and University of California, Berkeley.
7 * May 25, 2001
8 *
9 * .. Scalar Arguments ..
10  CHARACTER UPLO
11  INTEGER IA, INFO, JA, LWORK, N
12 * ..
13 * .. Array Arguments ..
14  INTEGER DESCA( * )
15  REAL A( * ), D( * ), E( * ), TAU( * ), WORK( * )
16 * ..
17 * Bugs
18 * ====
19 *
20 *
21 * Support for UPLO='U' is limited to calling the old, slow, PSSYTRD
22 * code.
23 *
24 *
25 * Purpose
26 * =======
27 *
28 * PSSYNTRD is a prototype version of PSSYTRD which uses tailored
29 * codes (either the serial, SSYTRD, or the parallel code, PSSYTTRD)
30 * when the workspace provided by the user is adequate.
31 *
32 *
33 * PSSYNTRD reduces a real symmetric matrix sub( A ) to symmetric
34 * tridiagonal form T by an orthogonal similarity transformation:
35 * Q' * sub( A ) * Q = T, where sub( A ) = A(IA:IA+N-1,JA:JA+N-1).
36 *
37 * Features
38 * ========
39 *
40 * PSSYNTRD is faster than PSSYTRD on almost all matrices,
41 * particularly small ones (i.e. N < 500 * sqrt(P) ), provided that
42 * enough workspace is available to use the tailored codes.
43 *
44 * The tailored codes provide performance that is essentially
45 * independent of the input data layout.
46 *
47 * The tailored codes place no restrictions on IA, JA, MB or NB.
48 * At present, IA, JA, MB and NB are restricted to those values allowed
49 * by PSSYTRD to keep the interface simple. These restrictions are
50 * documented below. (Search for "restrictions".)
51 *
52 * Notes
53 * =====
54 *
55 *
56 * Each global data object is described by an associated description
57 * vector. This vector stores the information required to establish
58 * the mapping between an object element and its corresponding process
59 * and memory location.
60 *
61 * Let A be a generic term for any 2D block cyclicly distributed array.
62 * Such a global array has an associated description vector DESCA.
63 * In the following comments, the character _ should be read as
64 * "of the global array".
65 *
66 * NOTATION STORED IN EXPLANATION
67 * --------------- -------------- --------------------------------------
68 * DTYPE_A(global) DESCA( DTYPE_ )The descriptor type. In this case,
69 * DTYPE_A = 1.
70 * CTXT_A (global) DESCA( CTXT_ ) The BLACS context handle, indicating
71 * the BLACS process grid A is distribu-
72 * ted over. The context itself is glo-
73 * bal, but the handle (the integer
74 * value) may vary.
75 * M_A (global) DESCA( M_ ) The number of rows in the global
76 * array A.
77 * N_A (global) DESCA( N_ ) The number of columns in the global
78 * array A.
79 * MB_A (global) DESCA( MB_ ) The blocking factor used to distribute
80 * the rows of the array.
81 * NB_A (global) DESCA( NB_ ) The blocking factor used to distribute
82 * the columns of the array.
83 * RSRC_A (global) DESCA( RSRC_ ) The process row over which the first
84 * row of the array A is distributed.
85 * CSRC_A (global) DESCA( CSRC_ ) The process column over which the
86 * first column of the array A is
87 * distributed.
88 * LLD_A (local) DESCA( LLD_ ) The leading dimension of the local
89 * array. LLD_A >= MAX(1,LOCr(M_A)).
90 *
91 * Let K be the number of rows or columns of a distributed matrix,
92 * and assume that its process grid has dimension p x q.
93 * LOCr( K ) denotes the number of elements of K that a process
94 * would receive if K were distributed over the p processes of its
95 * process column.
96 * Similarly, LOCc( K ) denotes the number of elements of K that a
97 * process would receive if K were distributed over the q processes of
98 * its process row.
99 * The values of LOCr() and LOCc() may be determined via a call to the
100 * ScaLAPACK tool function, NUMROC:
101 * LOCr( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
102 * LOCc( N ) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).
103 * An upper bound for these quantities may be computed by:
104 * LOCr( M ) <= ceil( ceil(M/MB_A)/NPROW )*MB_A
105 * LOCc( N ) <= ceil( ceil(N/NB_A)/NPCOL )*NB_A
106 *
107 *
108 * Arguments
109 * =========
110 *
111 * UPLO (global input) CHARACTER
112 * Specifies whether the upper or lower triangular part of the
113 * symmetric matrix sub( A ) is stored:
114 * = 'U': Upper triangular
115 * = 'L': Lower triangular
116 *
117 * N (global input) INTEGER
118 * The number of rows and columns to be operated on, i.e. the
119 * order of the distributed submatrix sub( A ). N >= 0.
120 *
121 * A (local input/local output) REAL pointer into the
122 * local memory to an array of dimension (LLD_A,LOCc(JA+N-1)).
123 * On entry, this array contains the local pieces of the
124 * symmetric distributed matrix sub( A ). If UPLO = 'U', the
125 * leading N-by-N upper triangular part of sub( A ) contains
126 * the upper triangular part of the matrix, and its strictly
127 * lower triangular part is not referenced. If UPLO = 'L', the
128 * leading N-by-N lower triangular part of sub( A ) contains the
129 * lower triangular part of the matrix, and its strictly upper
130 * triangular part is not referenced. On exit, if UPLO = 'U',
131 * the diagonal and first superdiagonal of sub( A ) are over-
132 * written by the corresponding elements of the tridiagonal
133 * matrix T, and the elements above the first superdiagonal,
134 * with the array TAU, represent the orthogonal matrix Q as a
135 * product of elementary reflectors; if UPLO = 'L', the diagonal
136 * and first subdiagonal of sub( A ) are overwritten by the
137 * corresponding elements of the tridiagonal matrix T, and the
138 * elements below the first subdiagonal, with the array TAU,
139 * represent the orthogonal matrix Q as a product of elementary
140 * reflectors. See Further Details.
141 *
142 * IA (global input) INTEGER
143 * The row index in the global array A indicating the first
144 * row of sub( A ).
145 *
146 * JA (global input) INTEGER
147 * The column index in the global array A indicating the
148 * first column of sub( A ).
149 *
150 * DESCA (global and local input) INTEGER array of dimension DLEN_.
151 * The array descriptor for the distributed matrix A.
152 *
153 * D (local output) REAL array, dimension LOCc(JA+N-1)
154 * The diagonal elements of the tridiagonal matrix T:
155 * D(i) = A(i,i). D is tied to the distributed matrix A.
156 *
157 * E (local output) REAL array, dimension LOCc(JA+N-1)
158 * if UPLO = 'U', LOCc(JA+N-2) otherwise. The off-diagonal
159 * elements of the tridiagonal matrix T: E(i) = A(i,i+1) if
160 * UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'. E is tied to the
161 * distributed matrix A.
162 *
163 * TAU (local output) REAL, array, dimension
164 * LOCc(JA+N-1). This array contains the scalar factors TAU of
165 * the elementary reflectors. TAU is tied to the distributed
166 * matrix A.
167 *
168 * WORK (local workspace/local output) REAL array,
169 * dimension (LWORK)
170 * On exit, WORK( 1 ) returns the optimal LWORK.
171 *
172 * LWORK (local or global input) INTEGER
173 * The dimension of the array WORK.
174 * LWORK is local input and must be at least
175 * LWORK >= MAX( NB * ( NP +1 ), 3 * NB )
176 *
177 * For optimal performance, greater workspace is needed, i.e.
178 * LWORK >= 2*( ANB+1 )*( 4*NPS+2 ) + ( NPS + 4 ) * NPS
179 * ICTXT = DESCA( CTXT_ )
180 * ANB = PJLAENV( ICTXT, 3, 'PSSYTTRD', 'L', 0, 0, 0, 0 )
181 * SQNPC = INT( SQRT( REAL( NPROW * NPCOL ) ) )
182 * NPS = MAX( NUMROC( N, 1, 0, 0, SQNPC ), 2*ANB )
183 *
184 * NUMROC is a ScaLAPACK tool functions;
185 * PJLAENV is a ScaLAPACK envionmental inquiry function
186 * MYROW, MYCOL, NPROW and NPCOL can be determined by calling
187 * the subroutine BLACS_GRIDINFO.
188 *
189 *
190 * INFO (global output) INTEGER
191 * = 0: successful exit
192 * < 0: If the i-th argument is an array and the j-entry had
193 * an illegal value, then INFO = -(i*100+j), if the i-th
194 * argument is a scalar and had an illegal value, then
195 * INFO = -i.
196 *
197 * Further Details
198 * ===============
199 *
200 * If UPLO = 'U', the matrix Q is represented as a product of elementary
201 * reflectors
202 *
203 * Q = H(n-1) . . . H(2) H(1).
204 *
205 * Each H(i) has the form
206 *
207 * H(i) = I - tau * v * v'
208 *
209 * where tau is a real scalar, and v is a real vector with
210 * v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in
211 * A(ia:ia+i-2,ja+i), and tau in TAU(ja+i-1).
212 *
213 * If UPLO = 'L', the matrix Q is represented as a product of elementary
214 * reflectors
215 *
216 * Q = H(1) H(2) . . . H(n-1).
217 *
218 * Each H(i) has the form
219 *
220 * H(i) = I - tau * v * v'
221 *
222 * where tau is a real scalar, and v is a real vector with
223 * v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in
224 * A(ia+i+1:ia+n-1,ja+i-1), and tau in TAU(ja+i-1).
225 *
226 * The contents of sub( A ) on exit are illustrated by the following
227 * examples with n = 5:
228 *
229 * if UPLO = 'U': if UPLO = 'L':
230 *
231 * ( d e v2 v3 v4 ) ( d )
232 * ( d e v3 v4 ) ( e d )
233 * ( d e v4 ) ( v1 e d )
234 * ( d e ) ( v1 v2 e d )
235 * ( d ) ( v1 v2 v3 e d )
236 *
237 * where d and e denote diagonal and off-diagonal elements of T, and vi
238 * denotes an element of the vector defining H(i).
239 *
240 * Alignment requirements
241 * ======================
242 *
243 * The distributed submatrix sub( A ) must verify some alignment proper-
244 * ties, namely the following expression should be true:
245 * ( MB_A.EQ.NB_A .AND. IROFFA.EQ.ICOFFA .AND. IROFFA.EQ.0 ) with
246 * IROFFA = MOD( IA-1, MB_A ) and ICOFFA = MOD( JA-1, NB_A ).
247 *
248 * =====================================================================
249 *
250 * .. Parameters ..
251  INTEGER BLOCK_CYCLIC_2D, DLEN_, DTYPE_, CTXT_, M_, N_,
252  $ mb_, nb_, rsrc_, csrc_, lld_
253  parameter( block_cyclic_2d = 1, dlen_ = 9, dtype_ = 1,
254  $ ctxt_ = 2, m_ = 3, n_ = 4, mb_ = 5, nb_ = 6,
255  $ rsrc_ = 7, csrc_ = 8, lld_ = 9 )
256  REAL ONE
257  parameter( one = 1.0e+0 )
258 * ..
259 * .. Local Scalars ..
260  LOGICAL LQUERY, UPPER
261  CHARACTER COLCTOP, ROWCTOP
262  INTEGER ANB, CTXTB, I, IACOL, IAROW, ICOFFA, ICTXT,
263  $ iinfo, indb, indd, inde, indtau, indw, ipw,
264  $ iroffa, j, jb, jx, k, kk, llwork, lwmin, minsz,
265  $ mycol, mycolb, myrow, myrowb, nb, np, npcol,
266  $ npcolb, nprow, nprowb, nps, nq, onepmin, sqnpc,
267  $ ttlwmin
268 * ..
269 * .. Local Arrays ..
270  INTEGER DESCB( DLEN_ ), DESCW( DLEN_ ), IDUM1( 2 ),
271  $ idum2( 2 )
272 * ..
273 * .. External Subroutines ..
274  EXTERNAL blacs_get, blacs_gridexit, blacs_gridinfo,
275  $ blacs_gridinit, chk1mat, descset, igamn2d,
276  $ pchk1mat, pselset, pslamr1d, pslatrd, pssyr2k,
277  $ pssytd2, pssyttrd, pstrmr2d, pb_topget,
278  $ pb_topset, pxerbla, ssytrd
279 * ..
280 * .. External Functions ..
281  LOGICAL LSAME
282  INTEGER INDXG2L, INDXG2P, NUMROC, PJLAENV
283  EXTERNAL lsame, indxg2l, indxg2p, numroc, pjlaenv
284 * ..
285 * .. Intrinsic Functions ..
286  INTRINSIC ichar, int, max, min, mod, real, sqrt
287 * ..
288 * .. Executable Statements ..
289 *
290 * This is just to keep ftnchek and toolpack/1 happy
291  IF( block_cyclic_2d*csrc_*ctxt_*dlen_*dtype_*lld_*mb_*m_*nb_*n_*
292  $ rsrc_.LT.0 )RETURN
293 * Get grid parameters
294 *
295  ictxt = desca( ctxt_ )
296  CALL blacs_gridinfo( ictxt, nprow, npcol, myrow, mycol )
297 *
298 * Test the input parameters
299 *
300  info = 0
301  IF( nprow.EQ.-1 ) THEN
302  info = -( 600+ctxt_ )
303  ELSE
304  CALL chk1mat( n, 2, n, 2, ia, ja, desca, 6, info )
305  upper = lsame( uplo, 'U' )
306  IF( info.EQ.0 ) THEN
307  nb = desca( nb_ )
308  iroffa = mod( ia-1, desca( mb_ ) )
309  icoffa = mod( ja-1, desca( nb_ ) )
310  iarow = indxg2p( ia, nb, myrow, desca( rsrc_ ), nprow )
311  iacol = indxg2p( ja, nb, mycol, desca( csrc_ ), npcol )
312  np = numroc( n, nb, myrow, iarow, nprow )
313  nq = max( 1, numroc( n+ja-1, nb, mycol, desca( csrc_ ),
314  $ npcol ) )
315  lwmin = max( ( np+1 )*nb, 3*nb )
316  anb = pjlaenv( ictxt, 3, 'PSSYTTRD', 'L', 0, 0, 0, 0 )
317  minsz = pjlaenv( ictxt, 5, 'PSSYTTRD', 'L', 0, 0, 0, 0 )
318  sqnpc = int( sqrt( real( nprow*npcol ) ) )
319  nps = max( numroc( n, 1, 0, 0, sqnpc ), 2*anb )
320  ttlwmin = 2*( anb+1 )*( 4*nps+2 ) + ( nps+4 )*nps
321 *
322  work( 1 ) = real( ttlwmin )
323  lquery = ( lwork.EQ.-1 )
324  IF( .NOT.upper .AND. .NOT.lsame( uplo, 'L' ) ) THEN
325  info = -1
326 *
327 * The following two restrictions are not necessary provided
328 * that either of the tailored codes are used.
329 *
330  ELSE IF( iroffa.NE.icoffa .OR. icoffa.NE.0 ) THEN
331  info = -5
332  ELSE IF( desca( mb_ ).NE.desca( nb_ ) ) THEN
333  info = -( 600+nb_ )
334  ELSE IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
335  info = -11
336  END IF
337  END IF
338  IF( upper ) THEN
339  idum1( 1 ) = ichar( 'U' )
340  ELSE
341  idum1( 1 ) = ichar( 'L' )
342  END IF
343  idum2( 1 ) = 1
344  IF( lwork.EQ.-1 ) THEN
345  idum1( 2 ) = -1
346  ELSE
347  idum1( 2 ) = 1
348  END IF
349  idum2( 2 ) = 11
350  CALL pchk1mat( n, 2, n, 2, ia, ja, desca, 6, 2, idum1, idum2,
351  $ info )
352  END IF
353 *
354  IF( info.NE.0 ) THEN
355  CALL pxerbla( ictxt, 'PSSYNTRD', -info )
356  RETURN
357  ELSE IF( lquery ) THEN
358  RETURN
359  END IF
360 *
361 * Quick return if possible
362 *
363  IF( n.EQ.0 )
364  $ RETURN
365 *
366 *
367  onepmin = n*n + 3*n + 1
368  llwork = lwork
369  CALL igamn2d( ictxt, 'A', ' ', 1, 1, llwork, 1, 1, -1, -1, -1,
370  $ -1 )
371 *
372 *
373 *
374 * Use the serial, LAPACK, code: STRD on small matrices if we
375 * we have enough space.
376 *
377  nprowb = 0
378  IF( ( n.LT.minsz .OR. sqnpc.EQ.1 ) .AND. llwork.GE.onepmin .AND.
379  $ .NOT.upper ) THEN
380  nprowb = 1
381  nps = n
382  ELSE
383  IF( llwork.GE.ttlwmin .AND. .NOT.upper ) THEN
384  nprowb = sqnpc
385  END IF
386  END IF
387 *
388  IF( nprowb.GE.1 ) THEN
389  npcolb = nprowb
390  sqnpc = nprowb
391  indb = 1
392  indd = indb + nps*nps
393  inde = indd + nps
394  indtau = inde + nps
395  indw = indtau + nps
396  llwork = llwork - indw + 1
397 *
398  CALL blacs_get( ictxt, 10, ctxtb )
399  CALL blacs_gridinit( ctxtb, 'Row major', sqnpc, sqnpc )
400  CALL blacs_gridinfo( ctxtb, nprowb, npcolb, myrowb, mycolb )
401  CALL descset( descb, n, n, 1, 1, 0, 0, ctxtb, nps )
402 *
403  CALL pstrmr2d( uplo, 'N', n, n, a, ia, ja, desca, work( indb ),
404  $ 1, 1, descb, ictxt )
405 *
406 *
407 * Only those processors in context CTXTB are needed for a while
408 *
409  IF( nprowb.GT.0 ) THEN
410 *
411  IF( nprowb.EQ.1 ) THEN
412  CALL ssytrd( uplo, n, work( indb ), nps, work( indd ),
413  $ work( inde ), work( indtau ), work( indw ),
414  $ llwork, info )
415  ELSE
416 *
417  CALL pssyttrd( 'L', n, work( indb ), 1, 1, descb,
418  $ work( indd ), work( inde ),
419  $ work( indtau ), work( indw ), llwork,
420  $ info )
421 *
422  END IF
423  END IF
424 *
425 * All processors participate in moving the data back to the
426 * way that PSSYNTRD expects it.
427 *
428  CALL pslamr1d( n-1, work( inde ), 1, 1, descb, e, 1, ja,
429  $ desca )
430 *
431  CALL pslamr1d( n, work( indd ), 1, 1, descb, d, 1, ja, desca )
432 *
433  CALL pslamr1d( n, work( indtau ), 1, 1, descb, tau, 1, ja,
434  $ desca )
435 *
436  CALL pstrmr2d( uplo, 'N', n, n, work( indb ), 1, 1, descb, a,
437  $ ia, ja, desca, ictxt )
438 *
439  IF( myrowb.GE.0 )
440  $ CALL blacs_gridexit( ctxtb )
441 *
442  ELSE
443 *
444  CALL pb_topget( ictxt, 'Combine', 'Columnwise', colctop )
445  CALL pb_topget( ictxt, 'Combine', 'Rowwise', rowctop )
446  CALL pb_topset( ictxt, 'Combine', 'Columnwise', '1-tree' )
447  CALL pb_topset( ictxt, 'Combine', 'Rowwise', '1-tree' )
448 *
449  ipw = np*nb + 1
450 *
451  IF( upper ) THEN
452 *
453 * Reduce the upper triangle of sub( A ).
454 *
455  kk = mod( ja+n-1, nb )
456  IF( kk.EQ.0 )
457  $ kk = nb
458  CALL descset( descw, n, nb, nb, nb, iarow,
459  $ indxg2p( ja+n-kk, nb, mycol, desca( csrc_ ),
460  $ npcol ), ictxt, max( 1, np ) )
461 *
462  DO 10 k = n - kk + 1, nb + 1, -nb
463  jb = min( n-k+1, nb )
464  i = ia + k - 1
465  j = ja + k - 1
466 *
467 * Reduce columns I:I+NB-1 to tridiagonal form and form
468 * the matrix W which is needed to update the unreduced part of
469 * the matrix
470 *
471  CALL pslatrd( uplo, k+jb-1, jb, a, ia, ja, desca, d, e,
472  $ tau, work, 1, 1, descw, work( ipw ) )
473 *
474 * Update the unreduced submatrix A(IA:I-1,JA:J-1), using an
475 * update of the form:
476 * A(IA:I-1,JA:J-1) := A(IA:I-1,JA:J-1) - V*W' - W*V'
477 *
478  CALL pssyr2k( uplo, 'No transpose', k-1, jb, -one, a, ia,
479  $ j, desca, work, 1, 1, descw, one, a, ia,
480  $ ja, desca )
481 *
482 * Copy last superdiagonal element back into sub( A )
483 *
484  jx = min( indxg2l( j, nb, 0, iacol, npcol ), nq )
485  CALL pselset( a, i-1, j, desca, e( jx ) )
486 *
487  descw( csrc_ ) = mod( descw( csrc_ )+npcol-1, npcol )
488 *
489  10 CONTINUE
490 *
491 * Use unblocked code to reduce the last or only block
492 *
493  CALL pssytd2( uplo, min( n, nb ), a, ia, ja, desca, d, e,
494  $ tau, work, lwork, iinfo )
495 *
496  ELSE
497 *
498 * Reduce the lower triangle of sub( A )
499 *
500  kk = mod( ja+n-1, nb )
501  IF( kk.EQ.0 )
502  $ kk = nb
503  CALL descset( descw, n, nb, nb, nb, iarow, iacol, ictxt,
504  $ max( 1, np ) )
505 *
506  DO 20 k = 1, n - nb, nb
507  i = ia + k - 1
508  j = ja + k - 1
509 *
510 * Reduce columns I:I+NB-1 to tridiagonal form and form
511 * the matrix W which is needed to update the unreduced part
512 * of the matrix
513 *
514  CALL pslatrd( uplo, n-k+1, nb, a, i, j, desca, d, e, tau,
515  $ work, k, 1, descw, work( ipw ) )
516 *
517 * Update the unreduced submatrix A(I+NB:IA+N-1,I+NB:IA+N-1),
518 * using an update of the form: A(I+NB:IA+N-1,I+NB:IA+N-1) :=
519 * A(I+NB:IA+N-1,I+NB:IA+N-1) - V*W' - W*V'
520 *
521  CALL pssyr2k( uplo, 'No transpose', n-k-nb+1, nb, -one,
522  $ a, i+nb, j, desca, work, k+nb, 1, descw,
523  $ one, a, i+nb, j+nb, desca )
524 *
525 * Copy last subdiagonal element back into sub( A )
526 *
527  jx = min( indxg2l( j+nb-1, nb, 0, iacol, npcol ), nq )
528  CALL pselset( a, i+nb, j+nb-1, desca, e( jx ) )
529 *
530  descw( csrc_ ) = mod( descw( csrc_ )+1, npcol )
531 *
532  20 CONTINUE
533 *
534 * Use unblocked code to reduce the last or only block
535 *
536  CALL pssytd2( uplo, kk, a, ia+k-1, ja+k-1, desca, d, e, tau,
537  $ work, lwork, iinfo )
538  END IF
539 *
540  CALL pb_topset( ictxt, 'Combine', 'Columnwise', colctop )
541  CALL pb_topset( ictxt, 'Combine', 'Rowwise', rowctop )
542 *
543  END IF
544 *
545  work( 1 ) = real( ttlwmin )
546 *
547  RETURN
548 *
549 * End of PSSYNTRD
550 *
551  END
pssytd2
subroutine pssytd2(UPLO, N, A, IA, JA, DESCA, D, E, TAU, WORK, LWORK, INFO)
Definition: pssytd2.f:3
max
#define max(A, B)
Definition: pcgemr.c:180
pssyntrd
subroutine pssyntrd(UPLO, N, A, IA, JA, DESCA, D, E, TAU, WORK, LWORK, INFO)
Definition: pssyntrd.f:3
pselset
subroutine pselset(A, IA, JA, DESCA, ALPHA)
Definition: pselset.f:2
pslatrd
subroutine pslatrd(UPLO, N, NB, A, IA, JA, DESCA, D, E, TAU, W, IW, JW, DESCW, WORK)
Definition: pslatrd.f:3
pchk1mat
subroutine pchk1mat(MA, MAPOS0, NA, NAPOS0, IA, JA, DESCA, DESCAPOS0, NEXTRA, EX, EXPOS, INFO)
Definition: pchkxmat.f:3
descset
subroutine descset(DESC, M, N, MB, NB, IRSRC, ICSRC, ICTXT, LLD)
Definition: descset.f:3
chk1mat
subroutine chk1mat(MA, MAPOS0, NA, NAPOS0, IA, JA, DESCA, DESCAPOS0, INFO)
Definition: chk1mat.f:3
pssyttrd
subroutine pssyttrd(UPLO, N, A, IA, JA, DESCA, D, E, TAU, WORK, LWORK, INFO)
Definition: pssyttrd.f:3
pslamr1d
subroutine pslamr1d(N, A, IA, JA, DESCA, B, IB, JB, DESCB)
Definition: pslamr1d.f:2
pxerbla
subroutine pxerbla(ICTXT, SRNAME, INFO)
Definition: pxerbla.f:2
min
#define min(A, B)
Definition: pcgemr.c:181