SCALAPACK 2.2.2
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ 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 at line 25 of file pstrmv_.c.

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}
Int
#define Int
Definition Bconfig.h:22
F2C_CHAR
#define F2C_CHAR(a)
Definition pblas.h:124
C2F_CHAR
#define C2F_CHAR(a)
Definition pblas.h:125
CCOLUMN
#define CCOLUMN
Definition PBblacs.h:20
TOP_GET
#define TOP_GET
Definition PBblacs.h:50
COLUMN
#define COLUMN
Definition PBblacs.h:45
COMBINE
#define COMBINE
Definition PBblacs.h:49
CROW
#define CROW
Definition PBblacs.h:21
ROW
#define ROW
Definition PBblacs.h:46
Cblacs_gridinfo
void Cblacs_gridinfo()
Csgsum2d
void Csgsum2d()
LEFT
#define LEFT
Definition PBblas.h:55
CNOUNIT
#define CNOUNIT
Definition PBblas.h:33
NOCONJG
#define NOCONJG
Definition PBblas.h:45
CUPPER
#define CUPPER
Definition PBblas.h:26
CNOTRAN
#define CNOTRAN
Definition PBblas.h:18
sgemv_
#define sgemv_
Definition PBblas.h:139
CTRAN
#define CTRAN
Definition PBblas.h:20
LOWER
#define LOWER
Definition PBblas.h:51
CCOTRAN
#define CCOTRAN
Definition PBblas.h:22
UPPER
#define UPPER
Definition PBblas.h:52
CLOWER
#define CLOWER
Definition PBblas.h:25
CUNIT
#define CUNIT
Definition PBblas.h:32
pilaenv_
#define pilaenv_
Definition PBpblas.h:44
CTXT_
#define CTXT_
Definition PBtools.h:38
PB_Ctztrmv
void PB_Ctztrmv()
MB_
#define MB_
Definition PBtools.h:43
PB_Cabort
void PB_Cabort()
PB_Cchkvec
void PB_Cchkvec()
PB_Cinfog2l
void PB_Cinfog2l()
PB_Cptrm
void PB_Cptrm()
PB_Cchkmat
void PB_Cchkmat()
MIN
#define MIN(a_, b_)
Definition PBtools.h:76
Mptr
#define Mptr(a_, i_, j_, lda_, siz_)
Definition PBtools.h:132
PB_Cwarn
void PB_Cwarn()
LLD_
#define LLD_
Definition PBtools.h:47
PB_Cnumroc
Int PB_Cnumroc()
PB_Ctop
char * PB_Ctop()
PB_CInV
void PB_CInV()
PB_Cstypeset
PBTYP_T * PB_Cstypeset()
Definition PB_Cstypeset.c:19
PB_CInOutV
void PB_CInOutV()
RSRC_
#define RSRC_
Definition PBtools.h:45
M_
#define M_
Definition PBtools.h:39
INB_
#define INB_
Definition PBtools.h:42
PB_CargFtoC
void PB_CargFtoC()
CSRC_
#define CSRC_
Definition PBtools.h:46
PB_Clcm
Int PB_Clcm()
IMB_
#define IMB_
Definition PBtools.h:41
Mupcase
#define Mupcase(C)
Definition PBtools.h:83
DLEN_
#define DLEN_
Definition PBtools.h:48
NB_
#define NB_
Definition PBtools.h:44
PB_Cpaxpby
void PB_Cpaxpby()
PB_Cdescribe
void PB_Cdescribe()
sset_
#define sset_
Definition PBtools.h:663
PBTYP_T::type
char type
Definition pblas.h:331
PBTYP_T::size
Int size
Definition pblas.h:333
PBTYP_T::zero
char * zero
Definition pblas.h:335
PBTYP_T::one
char * one
Definition pblas.h:336
PBTYP_T
Definition pblas.h:330
Here is the call graph for this function: