ScaLAPACK 2.1  2.1
ScaLAPACK: Scalable Linear Algebra PACKage
pstrmv_.c
Go to the documentation of this file.
1 /* ---------------------------------------------------------------------
2 *
3 * -- PBLAS routine (version 2.0) --
4 * University of Tennessee, Knoxville, Oak Ridge National Laboratory,
5 * and University of California, Berkeley.
6 * April 1, 1998
7 *
8 * ---------------------------------------------------------------------
9 */
10 /*
11 * Include files
12 */
13 #include "pblas.h"
14 #include "PBpblas.h"
15 #include "PBtools.h"
16 #include "PBblacs.h"
17 #include "PBblas.h"
18 
19 #ifdef __STDC__
20 void pstrmv_( F_CHAR_T UPLO, F_CHAR_T TRANS, F_CHAR_T DIAG, int * N,
21  float * A, int * IA, int * JA, int * DESCA,
22  float * X, int * IX, int * JX, int * DESCX,
23  int * INCX )
24 #else
25 void pstrmv_( UPLO, TRANS, DIAG, N, A, IA, JA, DESCA, X, IX, JX,
26  DESCX, INCX )
27 /*
28 * .. Scalar Arguments ..
29 */
30  F_CHAR_T DIAG, TRANS, UPLO;
31  int * IA, * INCX, * IX, * JA, * JX, * N;
32 /*
33 * .. Array Arguments ..
34 */
35  int * DESCA, * DESCX;
36  float * A, * X;
37 #endif
38 {
39 /*
40 * Purpose
41 * =======
42 *
43 * PSTRMV performs one of the matrix-vector operations
44 *
45 * sub( X ) := sub( A )*sub( X ) or sub( X ) := sub( A )'*sub( X ),
46 *
47 * where
48 *
49 * sub( A ) denotes A(IA:IA+N-1,JA:JA+N-1), and,
50 *
51 * sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
52 * X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X.
53 *
54 * sub( X ) is an n element subvector and sub( A ) is an n by n unit,
55 * or non-unit, upper or lower triangular submatrix.
56 *
57 * Notes
58 * =====
59 *
60 * A description vector is associated with each 2D block-cyclicly dis-
61 * tributed matrix. This vector stores the information required to
62 * establish the mapping between a matrix entry and its corresponding
63 * process and memory location.
64 *
65 * In the following comments, the character _ should be read as
66 * "of the distributed matrix". Let A be a generic term for any 2D
67 * block cyclicly distributed matrix. Its description vector is DESC_A:
68 *
69 * NOTATION STORED IN EXPLANATION
70 * ---------------- --------------- ------------------------------------
71 * DTYPE_A (global) DESCA[ DTYPE_ ] The descriptor type.
72 * CTXT_A (global) DESCA[ CTXT_ ] The BLACS context handle, indicating
73 * the NPROW x NPCOL BLACS process grid
74 * A is distributed over. The context
75 * itself is global, but the handle
76 * (the integer value) may vary.
77 * M_A (global) DESCA[ M_ ] The number of rows in the distribu-
78 * ted matrix A, M_A >= 0.
79 * N_A (global) DESCA[ N_ ] The number of columns in the distri-
80 * buted matrix A, N_A >= 0.
81 * IMB_A (global) DESCA[ IMB_ ] The number of rows of the upper left
82 * block of the matrix A, IMB_A > 0.
83 * INB_A (global) DESCA[ INB_ ] The number of columns of the upper
84 * left block of the matrix A,
85 * INB_A > 0.
86 * MB_A (global) DESCA[ MB_ ] The blocking factor used to distri-
87 * bute the last M_A-IMB_A rows of A,
88 * MB_A > 0.
89 * NB_A (global) DESCA[ NB_ ] The blocking factor used to distri-
90 * bute the last N_A-INB_A columns of
91 * A, NB_A > 0.
92 * RSRC_A (global) DESCA[ RSRC_ ] The process row over which the first
93 * row of the matrix A is distributed,
94 * NPROW > RSRC_A >= 0.
95 * CSRC_A (global) DESCA[ CSRC_ ] The process column over which the
96 * first column of A is distributed.
97 * NPCOL > CSRC_A >= 0.
98 * LLD_A (local) DESCA[ LLD_ ] The leading dimension of the local
99 * array storing the local blocks of
100 * the distributed matrix A,
101 * IF( Lc( 1, N_A ) > 0 )
102 * LLD_A >= MAX( 1, Lr( 1, M_A ) )
103 * ELSE
104 * LLD_A >= 1.
105 *
106 * Let K be the number of rows of a matrix A starting at the global in-
107 * dex IA,i.e, A( IA:IA+K-1, : ). Lr( IA, K ) denotes the number of rows
108 * that the process of row coordinate MYROW ( 0 <= MYROW < NPROW ) would
109 * receive if these K rows were distributed over NPROW processes. If K
110 * is the number of columns of a matrix A starting at the global index
111 * JA, i.e, A( :, JA:JA+K-1, : ), Lc( JA, K ) denotes the number of co-
112 * lumns that the process MYCOL ( 0 <= MYCOL < NPCOL ) would receive if
113 * these K columns were distributed over NPCOL processes.
114 *
115 * The values of Lr() and Lc() may be determined via a call to the func-
116 * tion PB_Cnumroc:
117 * Lr( IA, K ) = PB_Cnumroc( K, IA, IMB_A, MB_A, MYROW, RSRC_A, NPROW )
118 * Lc( JA, K ) = PB_Cnumroc( K, JA, INB_A, NB_A, MYCOL, CSRC_A, NPCOL )
119 *
120 * Arguments
121 * =========
122 *
123 * UPLO (global input) CHARACTER*1
124 * On entry, UPLO specifies whether the submatrix sub( A ) is
125 * an upper or lower triangular submatrix as follows:
126 *
127 * UPLO = 'U' or 'u' sub( A ) is an upper triangular
128 * submatrix,
129 *
130 * UPLO = 'L' or 'l' sub( A ) is a lower triangular
131 * submatrix.
132 *
133 * TRANS (global input) CHARACTER*1
134 * On entry, TRANS specifies the operation to be performed as
135 * follows:
136 *
137 * TRANS = 'N' or 'n' sub( X ) := sub( A ) * sub( X ).
138 *
139 * TRANS = 'T' or 't' sub( X ) := sub( A )' * sub( X ).
140 *
141 * TRANS = 'C' or 'c' sub( X ) := sub( A )' * sub( X ).
142 *
143 * DIAG (global input) CHARACTER*1
144 * On entry, DIAG specifies whether or not sub( A ) is unit
145 * triangular as follows:
146 *
147 * DIAG = 'U' or 'u' sub( A ) is assumed to be unit trian-
148 * gular,
149 *
150 * DIAG = 'N' or 'n' sub( A ) is not assumed to be unit tri-
151 * angular.
152 *
153 * N (global input) INTEGER
154 * On entry, N specifies the order of the submatrix sub( A ).
155 * N must be at least zero.
156 *
157 * A (local input) REAL array
158 * On entry, A is an array of dimension (LLD_A, Ka), where Ka is
159 * at least Lc( 1, JA+N-1 ). Before entry, this array contains
160 * the local entries of the matrix A.
161 * Before entry with UPLO = 'U' or 'u', this array contains the
162 * local entries corresponding to the entries of the upper tri-
163 * angular submatrix sub( A ), and the local entries correspon-
164 * ding to the entries of the strictly lower triangular part of
165 * the submatrix sub( A ) are not referenced.
166 * Before entry with UPLO = 'L' or 'l', this array contains the
167 * local entries corresponding to the entries of the lower tri-
168 * angular submatrix sub( A ), and the local entries correspon-
169 * ding to the entries of the strictly upper triangular part of
170 * the submatrix sub( A ) are not referenced.
171 * Note that when DIAG = 'U' or 'u', the local entries corres-
172 * ponding to the diagonal elements of the submatrix sub( A )
173 * are not referenced either, but are assumed to be unity.
174 *
175 * IA (global input) INTEGER
176 * On entry, IA specifies A's global row index, which points to
177 * the beginning of the submatrix sub( A ).
178 *
179 * JA (global input) INTEGER
180 * On entry, JA specifies A's global column index, which points
181 * to the beginning of the submatrix sub( A ).
182 *
183 * DESCA (global and local input) INTEGER array
184 * On entry, DESCA is an integer array of dimension DLEN_. This
185 * is the array descriptor for the matrix A.
186 *
187 * X (local input/local output) REAL array
188 * On entry, X is an array of dimension (LLD_X, Kx), where LLD_X
189 * is at least MAX( 1, Lr( 1, IX ) ) when INCX = M_X and
190 * MAX( 1, Lr( 1, IX+N-1 ) ) otherwise, and, Kx is at least
191 * Lc( 1, JX+N-1 ) when INCX = M_X and Lc( 1, JX ) otherwise.
192 * Before entry, this array contains the local entries of the
193 * matrix X. On exit, sub( X ) is overwritten with the transfor-
194 * med subvector.
195 *
196 * IX (global input) INTEGER
197 * On entry, IX specifies X's global row index, which points to
198 * the beginning of the submatrix sub( X ).
199 *
200 * JX (global input) INTEGER
201 * On entry, JX specifies X's global column index, which points
202 * to the beginning of the submatrix sub( X ).
203 *
204 * DESCX (global and local input) INTEGER array
205 * On entry, DESCX is an integer array of dimension DLEN_. This
206 * is the array descriptor for the matrix X.
207 *
208 * INCX (global input) INTEGER
209 * On entry, INCX specifies the global increment for the
210 * elements of X. Only two values of INCX are supported in
211 * this version, namely 1 and M_X. INCX must not be zero.
212 *
213 * -- Written on April 1, 1998 by
214 * Antoine Petitet, University of Tennessee, Knoxville 37996, USA.
215 *
216 * ---------------------------------------------------------------------
217 */
218 /*
219 * .. Local Scalars ..
220 */
221  char DiagA, TranOp, UploA, Xroc, * one, * tbeta, top, *zero;
222  int Acol, Ai, Aii, Aimb1, Ainb1, Aj, Ajj, Akp, Akq, Ald, Amb,
223  Amp, Amp0, Anb, Anq, Anq0, Arow, XAfr, XAld, Xcol, Xi, Xii,
224  Xj, Xjj, Xld, Xnp, Xnq, Xrow, YAfr, YAld, YApbY, YAsum,
225  ctxt, info, ione=1, k, kb, ktmp, mycol, myrow, nb, notran,
226  nounit, npcol, nprow, size, upper;
227  PBTYP_T * type;
228 /*
229 * .. Local Arrays ..
230 */
231  int Ad [DLEN_], Ad0[DLEN_], XAd[DLEN_], Xd[DLEN_], YAd[DLEN_];
232  char * Aptr = NULL, * XA = NULL, * YA = NULL;
233 /* ..
234 * .. Executable Statements ..
235 *
236 */
237  upper = ( ( UploA = Mupcase( F2C_CHAR( UPLO )[0] ) ) == CUPPER );
238  notran = ( ( TranOp = Mupcase( F2C_CHAR( TRANS )[0] ) ) == CNOTRAN );
239  nounit = ( ( DiagA = Mupcase( F2C_CHAR( DIAG )[0] ) ) == CNOUNIT );
240  PB_CargFtoC( *IA, *JA, DESCA, &Ai, &Aj, Ad );
241  PB_CargFtoC( *IX, *JX, DESCX, &Xi, &Xj, Xd );
242 #ifndef NO_ARGCHK
243 /*
244 * Test the input parameters
245 */
246  Cblacs_gridinfo( ( ctxt = Ad[CTXT_] ), &nprow, &npcol, &myrow, &mycol );
247  if( !( info = ( ( nprow == -1 ) ? -( 801 + CTXT_ ) : 0 ) ) )
248  {
249  if( ( !upper ) && ( UploA != CLOWER ) )
250  {
251  PB_Cwarn( ctxt, __LINE__, "PSTRMV", "Illegal UPLO = %c\n", UploA );
252  info = -1;
253  }
254  else if( ( !notran ) && ( TranOp != CTRAN ) && ( TranOp != CCOTRAN ) )
255  {
256  PB_Cwarn( ctxt, __LINE__, "PSTRMV", "Illegal TRANS = %c\n", TranOp );
257  info = -2;
258  }
259  else if( ( !nounit ) && ( DiagA != CUNIT ) )
260  {
261  PB_Cwarn( ctxt, __LINE__, "PSTRMV", "Illegal DIAG = %c\n", DiagA );
262  info = -3;
263  }
264  PB_Cchkmat( ctxt, "PSTRMV", "A", *N, 4, *N, 4, Ai, Aj, Ad, 8, &info );
265  PB_Cchkvec( ctxt, "PSTRMV", "X", *N, 4, Xi, Xj, Xd, *INCX, 12, &info );
266  }
267  if( info ) { PB_Cabort( ctxt, "PSTRMV", info ); return; }
268 #endif
269 /*
270 * Quick return if possible
271 */
272  if( *N == 0 ) return;
273 /*
274 * Retrieve process grid information
275 */
276 #ifdef NO_ARGCHK
277  Cblacs_gridinfo( ( ctxt = Ad[CTXT_] ), &nprow, &npcol, &myrow, &mycol );
278 #endif
279 /*
280 * Get type structure
281 */
282  type = PB_Cstypeset();
283  size = type->size; one = type->one; zero = type->zero;
284 /*
285 * Compute descriptor Ad0 for sub( A )
286 */
287  PB_Cdescribe( *N, *N, Ai, Aj, Ad, nprow, npcol, myrow, mycol, &Aii, &Ajj,
288  &Ald, &Aimb1, &Ainb1, &Amb, &Anb, &Arow, &Acol, Ad0 );
289 
290  Xroc = ( *INCX == Xd[M_] ? CROW : CCOLUMN );
291 
292  if( notran )
293  {
294 /*
295 * Replicate sub( X ) in process rows spanned by sub( A ) -> XA
296 */
297  PB_CInV( type, NOCONJG, ROW, *N, *N, Ad0, 1, ((char *) X), Xi, Xj, Xd,
298  &Xroc, &XA, XAd, &XAfr );
299 /*
300 * Reuse sub( X ) and/or create vector YA in process columns spanned by sub( A )
301 */
302  PB_CInOutV( type, COLUMN, *N, *N, Ad0, 1, one, ((char *) X), Xi, Xj, Xd,
303  &Xroc, &tbeta, &YA, YAd, &YAfr, &YAsum, &YApbY );
304 /*
305 * If sub( X ) is distributed in (a) process column(s), then zero it.
306 */
307  if( Xroc == CCOLUMN )
308  {
309 /*
310 * Retrieve sub( X )'s local information: Xii, Xjj, Xrow, Xcol
311 */
312  PB_Cinfog2l( Xi, Xj, Xd, nprow, npcol, myrow, mycol, &Xii, &Xjj, &Xrow,
313  &Xcol );
314 /*
315 * sub( X ) resides in (a) process columns(s)
316 */
317  if( ( mycol == Xcol ) || ( Xcol < 0 ) )
318  {
319 /*
320 * Make sure I own some data and scale sub( X )
321 */
322  Xnp = PB_Cnumroc( *N, Xi, Xd[IMB_], Xd[MB_], myrow, Xd[RSRC_],
323  nprow );
324  if( Xnp > 0 )
325  {
326  sset_( &Xnp, zero, Mptr( ((char *) X), Xii, Xjj, Xd[LLD_],
327  size ), &ione );
328  }
329  }
330  }
331  }
332  else
333  {
334 /*
335 * Replicate sub( X ) in process columns spanned by sub( A ) -> XA
336 */
337  PB_CInV( type, NOCONJG, COLUMN, *N, *N, Ad0, 1, ((char *) X), Xi, Xj, Xd,
338  &Xroc, &XA, XAd, &XAfr );
339 /*
340 * Reuse sub( X ) and/or create vector YA in process rows spanned by sub( A )
341 */
342  PB_CInOutV( type, ROW, *N, *N, Ad0, 1, one, ((char *) X), Xi, Xj, Xd,
343  &Xroc, &tbeta, &YA, YAd, &YAfr, &YAsum, &YApbY );
344 /*
345 * If sub( X ) is distributed in (a) process row(s), then zero it.
346 */
347  if( Xroc == CROW )
348  {
349 /*
350 * Retrieve sub( X )'s local information: Xii, Xjj, Xrow, Xcol
351 */
352  PB_Cinfog2l( Xi, Xj, Xd, nprow, npcol, myrow, mycol, &Xii, &Xjj, &Xrow,
353  &Xcol );
354 /*
355 * sub( X ) resides in (a) process row(s)
356 */
357  if( ( myrow == Xrow ) || ( Xrow < 0 ) )
358  {
359 /*
360 * Make sure I own some data and scale sub( X )
361 */
362  Xnq = PB_Cnumroc( *N, Xj, Xd[INB_], Xd[NB_], mycol, Xd[CSRC_],
363  npcol );
364  if( Xnq > 0 )
365  {
366  Xld = Xd[LLD_];
367  sset_( &Xnq, zero, Mptr( ((char *) X), Xii, Xjj, Xld,
368  size ), &Xld );
369  }
370  }
371  }
372  }
373 /*
374 * Local matrix-vector multiply iff I own some data
375 */
376  Aimb1 = Ad0[IMB_ ]; Ainb1 = Ad0[INB_ ]; Amb = Ad0[MB_]; Anb = Ad0[NB_];
377  Acol = Ad0[CSRC_]; Arow = Ad0[RSRC_];
378  Amp = PB_Cnumroc( *N, 0, Aimb1, Amb, myrow, Arow, nprow );
379  Anq = PB_Cnumroc( *N, 0, Ainb1, Anb, mycol, Acol, npcol );
380 
381  if( ( Amp > 0 ) && ( Anq > 0 ) )
382  {
383  Aptr = Mptr( ((char *) A), Aii, Ajj, Ald, size );
384 
385  XAld = XAd[LLD_]; YAld = YAd[LLD_];
386 /*
387 * Computational partitioning size is computed as the product of the logical
388 * value returned by pilaenv_ and 2 * lcm( nprow, npcol ).
389 */
390  nb = 2 * pilaenv_( &ctxt, C2F_CHAR( &type->type ) ) *
391  PB_Clcm( ( Arow >= 0 ? nprow : 1 ), ( Acol >= 0 ? npcol : 1 ) );
392 
393  if( upper )
394  {
395  if( notran )
396  {
397  for( k = 0; k < *N; k += nb )
398  {
399  kb = *N - k; kb = MIN( kb, nb );
400  Akp = PB_Cnumroc( k, 0, Aimb1, Amb, myrow, Arow, nprow );
401  Akq = PB_Cnumroc( k, 0, Ainb1, Anb, mycol, Acol, npcol );
402  Anq0 = PB_Cnumroc( kb, k, Ainb1, Anb, mycol, Acol, npcol );
403  if( Akp > 0 && Anq0 > 0 )
404  {
405  sgemv_( TRANS, &Akp, &Anq0, one, Mptr( Aptr, 0, Akq, Ald,
406  size ), &Ald, Mptr( XA, 0, Akq, XAld, size ),
407  &XAld, one, YA, &ione );
408  }
409  PB_Cptrm( type, type, LEFT, UPPER, &TranOp, &DiagA, kb, 1, one,
410  Aptr, k, k, Ad0, Mptr( XA, 0, Akq, XAld, size ), XAld,
411  Mptr( YA, Akp, 0, YAld, size ), YAld, PB_Ctztrmv );
412  }
413  }
414  else
415  {
416  for( k = 0; k < *N; k += nb )
417  {
418  kb = *N - k; kb = MIN( kb, nb );
419  Akp = PB_Cnumroc( k, 0, Aimb1, Amb, myrow, Arow, nprow );
420  Akq = PB_Cnumroc( k, 0, Ainb1, Anb, mycol, Acol, npcol );
421  Anq0 = PB_Cnumroc( kb, k, Ainb1, Anb, mycol, Acol, npcol );
422  if( Akp > 0 && Anq0 > 0 )
423  {
424  sgemv_( TRANS, &Akp, &Anq0, one, Mptr( Aptr, 0, Akq, Ald,
425  size ), &Ald, XA, &ione, one, Mptr( YA, 0, Akq, YAld,
426  size ), &YAld );
427  }
428  PB_Cptrm( type, type, LEFT, UPPER, &TranOp, &DiagA, kb, 1, one,
429  Aptr, k, k, Ad0, Mptr( XA, Akp, 0, XAld, size ), XAld,
430  Mptr( YA, 0, Akq, YAld, size ), YAld, PB_Ctztrmv );
431  }
432  }
433  }
434  else
435  {
436  if( notran )
437  {
438  for( k = 0; k < *N; k += nb )
439  {
440  kb = *N - k; ktmp = k + ( kb = MIN( kb, nb ) );
441  Akp = PB_Cnumroc( k, 0, Aimb1, Amb, myrow, Arow, nprow );
442  Akq = PB_Cnumroc( k, 0, Ainb1, Anb, mycol, Acol, npcol );
443  PB_Cptrm( type, type, LEFT, LOWER, &TranOp, &DiagA, kb, 1, one,
444  Aptr, k, k, Ad0, Mptr( XA, 0, Akq, XAld, size ), XAld,
445  Mptr( YA, Akp, 0, YAld, size ), YAld, PB_Ctztrmv );
446  Akp = PB_Cnumroc( ktmp, 0, Aimb1, Amb, myrow, Arow, nprow );
447  Amp0 = Amp - Akp;
448  Anq0 = PB_Cnumroc( kb, k, Ainb1, Anb, mycol, Acol, npcol );
449  if( Amp0 > 0 && Anq0 > 0 )
450  {
451  sgemv_( TRANS, &Amp0, &Anq0, one,
452  Mptr( Aptr, Akp, Akq, Ald, size ), &Ald,
453  Mptr( XA, 0, Akq, XAld, size ), &XAld, one,
454  Mptr( YA, Akp, 0, YAld, size ), &ione );
455  }
456  }
457  }
458  else
459  {
460  for( k = 0; k < *N; k += nb )
461  {
462  kb = *N - k; ktmp = k + ( kb = MIN( kb, nb ) );
463  Akp = PB_Cnumroc( k, 0, Aimb1, Amb, myrow, Arow, nprow );
464  Akq = PB_Cnumroc( k, 0, Ainb1, Anb, mycol, Acol, npcol );
465  PB_Cptrm( type, type, LEFT, LOWER, &TranOp, &DiagA, kb, 1, one,
466  Aptr, k, k, Ad0, Mptr( XA, Akp, 0, XAld, size ), XAld,
467  Mptr( YA, 0, Akq, YAld, size ), YAld, PB_Ctztrmv );
468  Akp = PB_Cnumroc( ktmp, 0, Aimb1, Amb, myrow, Arow, nprow );
469  Amp0 = Amp - Akp;
470  Anq0 = PB_Cnumroc( kb, k, Ainb1, Anb, mycol, Acol, npcol );
471  if( Amp0 > 0 && Anq0 > 0 )
472  {
473  sgemv_( TRANS, &Amp0, &Anq0, one,
474  Mptr( Aptr, Akp, Akq, Ald, size ), &Ald,
475  Mptr( XA, Akp, 0, XAld, size ), &ione, one,
476  Mptr( YA, 0, Akq, YAld, size ), &YAld );
477  }
478  }
479  }
480  }
481  }
482  if( XAfr ) free( XA );
483 
484  if( notran )
485  {
486 /*
487 * Combine the partial column results into YA
488 */
489  if( YAsum && ( Amp > 0 ) )
490  {
491  top = *PB_Ctop( &ctxt, COMBINE, ROW, TOP_GET );
492  Csgsum2d( ctxt, ROW, &top, Amp, 1, YA, YAd[LLD_], myrow,
493  YAd[CSRC_] );
494  }
495 /*
496 * sub( X ) := YA (if necessary)
497 */
498  if( YApbY )
499  {
500  PB_Cpaxpby( type, NOCONJG, *N, 1, one, YA, 0, 0, YAd, COLUMN, zero,
501  ((char *) X), Xi, Xj, Xd, &Xroc );
502  }
503  }
504  else
505  {
506 /*
507 * Combine the partial row results into YA
508 */
509  if( YAsum && ( Anq > 0 ) )
510  {
511  top = *PB_Ctop( &ctxt, COMBINE, COLUMN, TOP_GET );
512  Csgsum2d( ctxt, COLUMN, &top, 1, Anq, YA, YAd[LLD_], YAd[RSRC_],
513  mycol );
514  }
515 /*
516 * sub( X ) := YA (if necessary)
517 */
518  if( YApbY )
519  {
520  PB_Cpaxpby( type, NOCONJG, 1, *N, one, YA, 0, 0, YAd, ROW, zero,
521  ((char *) X), Xi, Xj, Xd, &Xroc );
522  }
523  }
524  if( YAfr ) free( YA );
525 /*
526 * End of PSTRMV
527 */
528 }
M_
#define M_
Definition: PBtools.h:39
ROW
#define ROW
Definition: PBblacs.h:46
MB_
#define MB_
Definition: PBtools.h:43
PB_Cpaxpby
void PB_Cpaxpby()
PB_Cwarn
void PB_Cwarn()
NB_
#define NB_
Definition: PBtools.h:44
COLUMN
#define COLUMN
Definition: PBblacs.h:45
CSRC_
#define CSRC_
Definition: PBtools.h:46
pstrmv_
void pstrmv_(F_CHAR_T UPLO, F_CHAR_T TRANS, F_CHAR_T DIAG, int *N, float *A, int *IA, int *JA, int *DESCA, float *X, int *IX, int *JX, int *DESCX, int *INCX)
Definition: pstrmv_.c:25
PBblacs.h
PB_Ctztrmv
void PB_Ctztrmv()
PBtools.h
sset_
F_VOID_FCT sset_()
PBblas.h
CCOTRAN
#define CCOTRAN
Definition: PBblas.h:22
NOCONJG
#define NOCONJG
Definition: PBblas.h:45
PBTYP_T::type
char type
Definition: pblas.h:327
PBpblas.h
DLEN_
#define DLEN_
Definition: PBtools.h:48
CUNIT
#define CUNIT
Definition: PBblas.h:32
sgemv_
F_VOID_FCT sgemv_()
LLD_
#define LLD_
Definition: PBtools.h:47
PB_Cdescribe
void PB_Cdescribe()
F_CHAR_T
char * F_CHAR_T
Definition: pblas.h:118
CROW
#define CROW
Definition: PBblacs.h:21
PB_Cchkvec
void PB_Cchkvec()
UPPER
#define UPPER
Definition: PBblas.h:52
IMB_
#define IMB_
Definition: PBtools.h:41
pilaenv_
int pilaenv_()
PB_Cabort
void PB_Cabort()
CLOWER
#define CLOWER
Definition: PBblas.h:25
LEFT
#define LEFT
Definition: PBblas.h:55
F2C_CHAR
#define F2C_CHAR(a)
Definition: pblas.h:120
TOP_GET
#define TOP_GET
Definition: PBblacs.h:50
PB_Ctop
char * PB_Ctop()
RSRC_
#define RSRC_
Definition: PBtools.h:45
CNOTRAN
#define CNOTRAN
Definition: PBblas.h:18
PBTYP_T::one
char * one
Definition: pblas.h:331
PB_CargFtoC
void PB_CargFtoC()
COMBINE
#define COMBINE
Definition: PBblacs.h:49
PBTYP_T::size
int size
Definition: pblas.h:329
PB_Cinfog2l
void PB_Cinfog2l()
PB_Cchkmat
void PB_Cchkmat()
PB_Cnumroc
int PB_Cnumroc()
PB_Cstypeset
PBTYP_T * PB_Cstypeset()
Definition: PB_Cstypeset.c:19
PB_CInV
void PB_CInV()
PB_CInOutV
void PB_CInOutV()
PB_Cptrm
void PB_Cptrm()
MIN
#define MIN(a_, b_)
Definition: PBtools.h:76
CCOLUMN
#define CCOLUMN
Definition: PBblacs.h:20
INB_
#define INB_
Definition: PBtools.h:42
LOWER
#define LOWER
Definition: PBblas.h:51
C2F_CHAR
#define C2F_CHAR(a)
Definition: pblas.h:121
Cblacs_gridinfo
void Cblacs_gridinfo()
PBTYP_T
Definition: pblas.h:325
Mupcase
#define Mupcase(C)
Definition: PBtools.h:83
pblas.h
CUPPER
#define CUPPER
Definition: PBblas.h:26
CTRAN
#define CTRAN
Definition: PBblas.h:20
Mptr
#define Mptr(a_, i_, j_, lda_, siz_)
Definition: PBtools.h:132
CTXT_
#define CTXT_
Definition: PBtools.h:38
PBTYP_T::zero
char * zero
Definition: pblas.h:331
CNOUNIT
#define CNOUNIT
Definition: PBblas.h:33
Csgsum2d
void Csgsum2d()
PB_Clcm
int PB_Clcm()