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