## Parallel Basic Linear Algebra Subprograms (PBLAS)

All routines appear in the order in which they are listed on the PBLAS Quick Reference Card.

Clicking on the name of a routine will take you to a description of that routine and its parameters.

Routine names are type-dependent. The lower case 'v' is replaced as shown in the following table to arrive at the correct routine name for a given data type:

```    v                MEANING
-----     ------------------------------
S       Single precision real data
D       Double precision real data
C       Single precision complex data
Z       Double precision complex data
```

### Notes:

A description vector is associated with each 2D block-cyclicly distributed matrix. This vector stores the information required to establish the mapping between a matrix entry and its corresponding process and memory location.

In the following comments, the character _ should be read as "of the distributed matrix". Let A be a generic term for any 2D block cyclicly distributed matrix. Its description vector is DESC_A:

```NOTATION        STORED IN     EXPLANATION
--------------- ------------- ---------------------------------------
DT_A   (global) desc_A[DT_]   The descriptor type.
CTXT_A (global) desc_A[CTXT_] The BLACS context handle, indicating
the BLACS process grid A is distribu-
ted over. The context itself is global,
but the handle (the integer value) may
vary.
M_A    (global) desc_A[M_]    The number of rows in the distributed
matrix.
N_A    (global) desc_A[N_]    The number of columns in the distribu-
ted matrix.
MB_A   (global) desc_A[MB_]   The blocking factor used to distribute
the rows of the matrix.
NB_A   (global) desc_A[NB_]   The blocking factor used to distribute
the columns of the matrix.
RSRC_A (global) desc_A[RSRC_] The process row over which the first
row of the matrix is distributed.
CSRC_A (global) desc_A[CSRC_] The process column over which the first
column of the matrix is distributed.
LLD_A  (local)  desc_A[LLD_]  The leading dimension of the local
array storing the local blocks of the
distributed matrix A.
LLD_A >= MAX(1,LOCp(M_A)).
```

Let K be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q. LOCp( K ) denotes the number of elements of K that a process would receive if K were distributed over the p processes of its process column.

Similarly, LOCq( K ) denotes the number of elements of K that a process would receive if K were distributed over the q processes of its process row.

The values of LOCp() and LOCq() may be determined via a call to the ScaLAPACK tool function, NUMROC.

• LOCp( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
• LOCq( N ) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).

Because vectors may be seen as particular matrices, a distributed vector is considered to be a distributed matrix.

## Level 1 PBLAS

```  PvSWAP( N,             X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )
PvSCAL( N, ALPHA,      X, IX, JX, DESCX, INCX )
PvCOPY( N,             X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )
PvAXPY( N, ALPHA,      X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )
PvDOT ( N, DOT,        X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )
PvDOTU( N, DOTC,       X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )
PvDOTC( N, DOTU,       X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )
PvNRM2( N, NORM2,      X, IX, JX, DESCX, INCX )
PvASUM( N, ASUM,       X, IX, JX, DESCX, INCX )
PvAMAX( N, AMAX, INDX, X, IX, JX, DESCX, INCX )
```

## Level 2 PBLAS

```  PvGEMV(       TRANS,       M, N, ALPHA, A, IA, JA, DESCA, X, IX, JX, DESCX, INCX, BETA, Y, IY, JY, DESCY, INCY )
PvHEMV( UPLO,              M, N, ALPHA, A, IA, JA, DESCA, X, IX, JX, DESCX, INCX, BETA, Y, IY, JY, DESCY, INCY )
PvSYMV( UPLO,              M, N, ALPHA, A, IA, JA, DESCA, X, IX, JX, DESCX, INCX, BETA, Y, IY, JY, DESCY, INCY )
PvTRMV( UPLO, TRANS, DIAG, M, N,        A, IA, JA, DESCA, X, IX, JX, DESCX, INCX )
PvTRSV( UPLO, TRANS, DIAG,    N,        A, IA, JA, DESCA, X, IX, JX, DESCX, INCX )

PvGER (        M, N, ALPHA, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY, A, IA, JA, DESCA )
PvGERU (       M, N, ALPHA, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY, A, IA, JA, DESCA )
PvGERC (       M, N, ALPHA, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY, A, IA, JA, DESCA )
PvHER ( UPLO,     N, ALPHA, X, IX, JX, DESCX, INCX, A, IA, JA, DESCA )
PvHER2 (UPLO,     N, ALPHA, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY, A, IA, JA, DESCA )
PvSYR ( UPLO,     N, ALPHA, X, IX, JX, DESCX, INCX, A, IA, JA, DESCA )
PvSYR2 (UPLO,     N, ALPHA, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY, A, IA, JA, DESCA )
```

## Level 3 PBLAS

```  PvGEMM(            TRANSA, TRANSB,       M, N, K, ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB, BETA, C, IC, JC, DESCC )
PvSYMM( SIDE, UPLO,                      M, N,    ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB, BETA, C, IC, JC, DESCC )
PvHEMM( SIDE, UPLO,                      M, N,    ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB, BETA, C, IC, JC, DESCC )
PvSYRK(       UPLO, TRANS,                  N, K, ALPHA, A, IA, JA, DESCA,                   BETA, C, IC, JC, DESCC )
PvHERK(       UPLO, TRANS,                  N, K, ALPHA, A, IA, JA, DESCA,                   BETA, C, IC, JC, DESCC )
PvSYR2K(      UPLO, TRANS,                  N, K, ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB, BETA, C, IC, JC, DESCC )
PvHER2K(      UPLO, TRANS,                  N, K, ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB, BETA, C, IC, JC, DESCC )
PvTRAN(                                  M, N,    ALPHA, A, IA, JA, DESCA,                   BETA, C, IC, JC, DESCC )
PvTRANU(                                 M, N,    ALPHA, A, IA, JA, DESCA,                   BETA, C, IC, JC, DESCC )
PvTRANC(                                 M, N,    ALPHA, A, IA, JA, DESCA,                   BETA, C, IC, JC, DESCC )
PvTRMM( SIDE, UPLO, TRANSA,        DIAG, M, N,    ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB )
PvTRSM( SIDE, UPLO, TRANSA,        DIAG, M, N,    ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB )
```

## PvSWAP

SUBROUTINE PvSWAP( N, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )

Purpose

PvSWAP swaps two distributed vectors,

• sub( Y ) := sub( X ) and sub( X ) := sub( Y )
```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y.
```
Arguments

N
(global input) INTEGER
The length of the distributed vectors to be swapped. N >= 0.
X
(local input/local output) array of dimension ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ). On exit sub( X ) is overwritten by sub( Y ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
Y
(local input/local output) array of dimension ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ). On exit sub( Y ) is overwritten by sub( X ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.

## PvSCAL

SUBROUTINE PvSCAL( N, ALPHA, X, IX, JX, DESCX, INCX )

Purpose

PvSCAL multiplies an N-element real distributed vector sub( X ) by the real scalar alpha,

```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X.
```
Arguments

N
(global input) INTEGER
The number of components of the distributed vector sub( X ). N >= 0.
ALPHA
(global input) REAL/COMPLEX
The scalar used to multiply each component of sub( X ).
X
(local input/local output) array of dimension ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.

## PvCOPY

SUBROUTINE PvCOPY( N, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )

Purpose

PvCOPY copies one distributed vector into another,

• sub( Y ) := sub( X )
```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y.
```
Arguments

N
(global input) INTEGER
The length of the distributed vectors to be copied. N >= 0.
X
(local input/local output) array of dimension ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
Y
(local input/local output) array of dimension ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ). On exit sub( Y ) is overwritten by sub( X ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.

## PvAXPY

SUBROUTINE PvAXPY( N, ALPHA, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )

Purpose

PvAXPY adds one distributed vector to another,

• sub( Y ) := sub( Y ) + alpha * sub( X )
```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y.
```
Arguments

N
(global input) INTEGER
The length of the distributed vectors to be added. N >= 0.
ALPHA
(global input) REAL/COMPLEX
The scalar used to multiply each component of sub( X ).
X
(local input/local output) array of dimension ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
Y
(local input/local output) array of dimension ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ). On exit sub( Y ) is overwritten by sub( Y ) + alpha*sub( X ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.

## PvDOT

SUBROUTINE PvDOT( N, DOT, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )

Purpose

PvDOT forms the dot product of two distributed vectors,

• dot := sub( X )**T * sub( Y )
```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y.
```
Arguments

N
(global input) INTEGER
The length of the distributed vectors to be multiplied. N >= 0.
DOT
(local output) REAL
The dot product of sub( X ) and sub( Y ) only in their scope.
X
(local input/local output) array of dimension ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
Y
(local input/local output) array of dimension ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.

## PvDOTU

SUBROUTINE PvDOTU( N, DOTU, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )

Purpose

PvDOTU forms the dot product of two distributed vectors,

• dotu := sub( X )**T * sub( Y )
```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y.
```
Arguments

N
(global input) INTEGER
The length of the distributed vectors to be multiplied. N >= 0.
DOTU
(local output) COMPLEX
The dot product of sub( X ) and sub( Y ) only in their scope.
X
(local input/local output) COMPLEX array of dimension ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
Y
(local input/local output) COMPLEX array of dimension ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.

## PvDOTC

SUBROUTINE PvDOTC( N, DOTC, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY )

Purpose

PvDOTC forms the dot product of two distributed vectors,

• dotc := sub( X )**T * sub( Y )
```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y.
```
Arguments

N
(global input) INTEGER
The length of the distributed vectors to be multiplied. N >= 0.
DOTC
(local output) COMPLEX
The dot product of sub( X ) and sub( Y ) only in their scope.
X
(local input/local output) COMPLEX array of dimension ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
Y
(local input/local output) COMPLEX array of dimension ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.

## PvNRM2

SUBROUTINE PvNRM2( N, NORM2, X, IX, JX, DESCX, INCX )

Purpose

PvNRM2 returns the 2-norm of a distributed vector sub( X ),

```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X.
```
Arguments

N
(global input) INTEGER
The length of the distributed vectors to be multiplied. N >= 0.
NORM2
(local output) REAL/COMPLEX
The dot product of sub( X ) and sub( Y ) only in their scope.
X
(local input/local output) REAL/COMPLEX array of dimension ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.

## PvASUM

SUBROUTINE PvASUM( N, ASUM, X, IX, JX, DESCX, INCX )

Purpose

PvASUM returns the sum of absolute values of the entries of a distributed vector sub( X ),

```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X.
```
Arguments

N
(global input) INTEGER
The length of the distributed vectors to be multiplied. N >= 0.
ASUM
(local output) REAL/COMPLEX
The sum of absolute values of the distributed vector sub( X ) only in its scope.
X
(local input/local output) REAL/COMPLEX array of dimension ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.

## PvAMAX

SUBROUTINE PvAMAX( N, AMAX, INDX, X, IX, JX, DESCX, INCX )

Purpose

PvAMAX computes the global index of the maximum element in absolute value of a distributed vector sub( X ). The global index is returned in INDX and the value is returned in AMAX,

```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X.
```
Arguments

N
(global input) INTEGER
The length of the distributed vectors to be multiplied. N >= 0.
AMAX
(global output) REAL/COMPLEX
The absolute value of the largest entry of the distributed vector sub( X ) only in the scope of sub( X ).
INDX
(global output) INTEGER
The global index of the maximum element in absolute value of the distributed vector sub( X ) only in its scope.
X
(local input/local output) REAL/COMPLEX array of dimension ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.

## PvGEMV

SUBROUTINE PvGEMV( TRANS, M, N, ALPHA, A, IA, JA, DESCA, X, IX, JX, DESCX, INCX, BETA, Y, IY, JY, DESCY, INCY )

Purpose

PvGEMV performs one of the distributed matrix-vector operations

• sub( Y ) := alpha*sub( A ) * sub( X ) + beta*sub( Y ), or
• sub( Y ) := alpha*sub( A )' * sub( X ) + beta*sub( Y ),

where sub( A ) denotes A(IA:IA+M-1,JA:JA+N-1),

```      sub( X ) denotes if TRANS = 'N',
X(IX:IX,JX:JX+N-1), if INCX = M_X,
X(IX:IX+N-1,JX:JX), if INCX = 1 and INCX <> M_X,
else
X(IX:IX,JX:JX+M-1), if INCX = M_X,
X(IX:IX+M-1,JX:JX), if INCX = 1 and INCX <> M_X,
end if
sub( Y ) denotes if trans = 'N',
Y(IY:IY,JY:JY+M-1), if INCY = M_Y,
Y(IY:IY+M-1,JY:JY), if INCY = 1 and INCY <> M_Y,
else
Y(IY:IY,JY:JY+N-1), if INCY = M_Y,
Y(IY:IY+N-1,JY:JY), if INCY = 1 and INCY <> M_Y,
end if
```
alpha and beta are scalars, and sub( X ) and sub( Y ) are distributed vectors and sub( A ) is a M-by-N distributed submatrix.

Arguments

TRANS
(global input) CHARACTER
On entry, TRANS specifies the operation to be performed as follows:
• if TRANS = 'N',
• sub( Y ) := alpha*sub( A ) * sub( X ) + beta*sub( Y ),
• else if TRANS = 'T',
• sub( Y ) := alpha*sub( A )' * sub( X ) + beta*sub( Y ),
• else if TRANS = 'C',
• sub( Y ) := alpha*sub( A )' * sub( X ) + beta*sub( Y ).
M
(global input) INTEGER
The number of rows to be operated on i.e the number of rows of the distributed submatrix sub( A ). M >= 0.
N
(global input) INTEGER
The number of columns to be operated on i.e the number of columns of the distributed submatrix sub( A ). N >= 0.
ALPHA
(global input) REAL/COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) array of dimension (LLD_A, LOCq(JA+N-1))
This array contains the local pieces of the distributed matrix sub( A ).
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
X
(local input/local output) array of dimension at least
if TRANS = 'N',
• ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
else
• ( (JX-1)*M_X + IX + ( M - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
BETA
(global input) REAL/COMPLEX
On entry, BETA specifies the scalar beta. When BETA is supplied as zero then sub( Y ) need not be set on input.
Y
(local input/local output) array of dimension at least
if TRANS = 'N',
• ( (JY-1)*M_Y + IY + ( M - 1 )*abs( INCY ) )
else
• ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ). On exit, sub( Y ) is overwritten by the updated distributed vector sub( Y ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.

## PvHEMV

SUBROUTINE PvHEMV( UPLO, N, ALPHA, A, IA, JA, DESCA, X, IX, JX, DESCX, INCX, BETA, Y, IY, JY, DESCY, INCY )

Purpose

PvHEMV performs the distributed matrix-vector operation

• sub( Y ) := alpha*sub( A ) * sub( X ) + beta*sub( Y )

where sub( A ) denotes A(IA:IA+M-1,JA:JA+N-1),

```      sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y.
```
alpha and beta are scalars, sub( X ) and sub( Y ) are N element distributed vectors and sub( A ) is an N-by-N Hermitian distributed matrix.

Arguments

UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the upper or lower triangular part of the distributed matrix sub( A ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of sub( A ) is to be referenced.
• UPLO = 'L' Only the lower triangular part of sub( A ) is to be referenced.
N
(global input) INTEGER
The order of the distributed matrix sub( A ). N >= 0.
ALPHA
(global input) COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) COMPLEX array of dimension (LLD_A, LOCq(JA+N-1))
This array contains the local pieces of the distributed matrix sub( A ). Before entry with UPLO = 'U', the leading N-by-N upper triangular part of the distributed matrix sub( A ) must and the strictly lower triangular part of sub( A ) is not referenced.

Before entry with UPLO = 'L', the leading N-by-N lower triangular part of the distributed matrix sub( A ) must contain the lower triangular part of the Hermitian matrix and the strictly upper triangular part of sub( A ) is not referenced.

IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
X
(local input/local output) COMPLEX array of dimension at least ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
BETA
(global input) COMPLEX
On entry, BETA specifies the scalar beta. When BETA is supplied as zero then sub( Y ) need not be set on input.
Y
(local input/local output) COMPLEX array of dimension at least ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ). On exit, sub( Y ) is overwritten by the updated distributed vector sub( Y ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.

## PvSYMV

SUBROUTINE PvSYMV( UPLO, N, ALPHA, A, IA, JA, DESCA, X, IX, JX, DESCX, INCX, BETA, Y, IY, JY, DESCY, INCY )

Purpose

PvSYMV performs the distributed matrix-vector operation

• sub( Y ) := alpha*sub( A ) * sub( X ) + beta*sub( Y )

where sub( A ) denotes A(IA:IA+M-1,JA:JA+N-1),

```      sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y.
```
alpha and beta are scalars, sub( X ) and sub( Y ) are N element distributed vectors and sub( A ) is an N-by-N symmetric distributed matrix.

Arguments

UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the upper or lower triangular part of the distributed matrix sub( A ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of sub( A ) is to be referenced.
• UPLO = 'L' Only the lower triangular part of sub( A ) is to be referenced.
N
(global input) INTEGER
The order of the distributed matrix sub( A ). N >= 0.
ALPHA
(global input) REAL
On entry, ALPHA specifies the scalar alpha.
A
(local input) REAL array of dimension (LLD_A, LOCq(JA+N-1))
This array contains the local pieces of the distributed matrix sub( A ). Before entry with UPLO = 'U', the leading N-by-N upper triangular part of the distributed matrix sub( A ) must and the strictly lower triangular part of sub( A ) is not referenced.

Before entry with UPLO = 'L', the leading N-by-N lower triangular part of the distributed matrix sub( A ) must contain the lower triangular part of the symmetric matrix and the strictly upper triangular part of sub( A ) is not referenced.

IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
X
(local input/local output) REAL array of dimension at least ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
BETA
(global input) REAL
On entry, BETA specifies the scalar beta. When BETA is supplied as zero then sub( Y ) need not be set on input.
Y
(local input/local output) REAL array of dimension at least ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ). On exit, sub( Y ) is overwritten by the updated distributed vector sub( Y ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.

## PvTRMV

SUBROUTINE PvTRMV( UPLO, TRANS, DIAG, N, A, IA, JA, DESCA, X, IX, JX, DESCX, INCX )

Purpose

PvTRMV performs one of the distributed matrix-vector operations

• sub( X ) := sub( A )*sub( X ) or sub( X ) := sub( A )'*sub( X ),
where sub( A ) denotes A(IA:IA+N-1,JA:JA+N-1),
```      sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
```
sub( X ) is an N element vector and sub( A ) is an N-by-N unit, or non-unit, upper or lower triangular distributed matrix.

Arguments

UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the upper or lower triangular part of the distributed matrix sub( A ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of sub( A ) is to be referenced.
• UPLO = 'L' Only the lower triangular part of sub( A ) is to be referenced.
TRANS
(global input) CHARACTER
On entry, TRANS specifies the operation to be performed as follows:
• TRANS = 'N' sub( x ) := sub( A )*sub( x ).
• TRANS = 'T' sub( x ) := sub( A )'*sub( x ).
• TRANS = 'C' sub( x ) := sub( A )'*sub( x ).
DIAG
(global input) CHARACTER
On entry, DIAG specifies whether or not sub( A ) is unit triangular as follows:
• DIAG = 'U' sub( A ) is assumed to be unit triangular.
• DIAG = 'N' sub( A ) is not assumed to be unit triangular.
N
(global input) INTEGER
The order of the distributed matrix sub( A ). N >= 0.
A
(local input) array of dimension (LLD_A, LOCq(JA+N-1))
This array contains the local pieces of the distributed matrix sub( A ).

Before entry with UPLO = 'U', the leading N-by-N upper triangular part of the distributed matrix sub( A ) must contain the upper triangular distributed matrix and the strictly lower triangular part of sub( A ) is not referenced.

Before entry with UPLO = 'L', the leading N-by-N lower triangular part of the distributed matrix sub( A ) must contain the lower triangular distributed matrix and the strictly upper triangular part of sub( A ) is not referenced.

Note that when DIAG = 'U', the diagonal elements of sub( A ) are not referenced either, but are assumed to be unity.

IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
X
(local input/local output) array of dimension at least ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.

## PvTRSV

SUBROUTINE PvTRSV( UPLO, TRANS, DIAG, N, A, IA, JA, DESCA, X, IX, JX, DESCX, INCX )

Purpose

PvTRSV solves one of the systems of equations

• sub( A )*sub( X ) = b, or sub( A )'*sub( X ) = b,
where sub( A ) denotes A(IA:IA+N-1,JA:JA+N-1),
```      sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
```

b and sub( X ) are N element distributed vectors and sub( A ) is an N-by-N unit, or non-unit, upper or lower triangular distributed matrix.

No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.

Arguments

UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the distributed matrix sub( A ) is an upper or lower triangular matrix as follows:
• UPLO = 'U' sub( A ) is an upper triangular distributed matrix.
• UPLO = 'L' sub( A ) is a lower triangular distributed matrix.
TRANS
(global input) CHARACTER
On entry, TRANS specifies the operation to be performed as follows:
• TRANS = 'N' sub( A )*sub( X ) = b.
• TRANS = 'T' sub( A )'*sub( X ) = b.
• TRANS = 'C' sub( A )'*sub( X ) = b.
DIAG
(global input) CHARACTER
On entry, DIAG specifies whether or not sub( A ) is unit triangular as follows:
• DIAG = 'U' sub( A ) is assumed to be unit triangular.
• DIAG = 'N' sub( A ) is not assumed to be unit triangular.
N
(global input) INTEGER
The order of the distributed matrix sub( A ). N >= 0.
A
(local input) array of dimension (LLD_A, LOCq(JA+N-1))
This array contains the local pieces of the distributed matrix sub( A ).

Before entry with UPLO = 'U', the leading N-by-N upper triangular part of the distributed matrix sub( A ) must contain the upper triangular distributed matrix and the strictly lower triangular part of sub( A ) is not referenced.

Before entry with UPLO = 'L', the leading N-by-N lower triangular part of the distributed matrix sub( A ) must contain the lower triangular distributed matrix and the strictly upper triangular part of sub( A ) is not referenced.

Note that when DIAG = 'U', the diagonal elements of sub( A ) are not referenced either, but are assumed to be unity.

IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
X
(local input/local output) array of dimension at least ( (JX-1)*M_X + IX + ( N - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ). Before entry, sub( X ) must contain the N element right-hand side distributed vector b. On exit, sub( X ) is overwritten with the solution vector.
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.

## PvGER

SUBROUTINE PvGER( M, N, ALPHA, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY, A, IA, JA, DESCA )

Purpose

PvGER performs the rank 1 operation

• sub( A ) := alpha*sub( X )*sub( Y )' + sub( A ),
where sub( A ) denotes A(IA:IA+M-1,JA:JA+N-1),
```      sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y.
```

alpha is a scalar, sub( X ) is an M element distributed vector, sub( Y ) is an N element distributed vector and sub( A ) is an M-by-N distributed matrix.

Arguments

M
(global input) INTEGER
The number of rows to be operated on i.e the number of rows of the distributed submatrix sub( A ). M >= 0.
N
(global input) INTEGER
The number of columns to be operated on i.e the number of columns of the distributed submatrix sub( A ). N >= 0.
ALPHA
(global input) REAL
On entry, ALPHA specifies the scalar alpha.
X
(local input/local output) REAL array of dimension at least ( (JX-1)*M_X + IX + ( M - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
Y
(local input/local output) REAL array of dimension at least ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.
A
(local input) REAL array of dimension (LLD_A, LOCq(JA+N-1))
Before entry, the leading M-by-N part of the distributed matrix sub( A ) must contain the matrix of coefficients. On exit, sub( A ) is overwritten by the updated distributed matrix.
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.

## PvGERU

SUBROUTINE PvGERU( M, N, ALPHA, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY, A, IA, JA, DESCA )

Purpose

PvGERU performs the rank 1 operation

• sub( A ) := alpha*sub( X )*sub( Y )' + sub( A ),
where sub( A ) denotes A(IA:IA+M-1,JA:JA+N-1),
```      sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y.
```
alpha is a scalar, sub( X ) is an M element distributed vector, sub( Y ) is an N element distributed vector and sub( A ) is an M-by-N distributed matrix.

Arguments

M
(global input) INTEGER
The number of rows to be operated on i.e the number of rows of the distributed submatrix sub( A ). M >= 0.
N
(global input) INTEGER
The number of columns to be operated on i.e the number of columns of the distributed submatrix sub( A ). N >= 0.
ALPHA
(global input) COMPLEX
On entry, ALPHA specifies the scalar alpha.
X
(local input/local output) COMPLEX array of dimension at least ( (JX-1)*M_X + IX + ( M - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
Y
(local input/local output) COMPLEX array of dimension at least ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.
A
(local input) COMPLEX array of dimension (LLD_A, LOCq(JA+N-1))
Before entry, the leading M-by-N part of the distributed matrix sub( A ) must contain the matrix of coefficients. On exit, sub( A ) is overwritten by the updated distributed matrix.
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.

## PvGERC

SUBROUTINE PvGERC( M, N, ALPHA, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY, A, IA, JA, DESCA )

Purpose

PvGERC performs the rank 1 operation

• sub( A ) := alpha*sub( X )*conjg( sub( Y )' ) + sub( A ),
where sub( A ) denotes A(IA:IA+M-1,JA:JA+N-1),
```      sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y.
```
alpha is a scalar, sub( X ) is an M element distributed vector, sub( Y ) is an N element distributed vector and sub( A ) is an M-by-N distributed matrix.

Arguments

M
(global input) INTEGER
The number of rows to be operated on i.e the number of rows of the distributed submatrix sub( A ). M >= 0.
N
(global input) INTEGER
The number of columns to be operated on i.e the number of columns of the distributed submatrix sub( A ). N >= 0.
ALPHA
(global input) COMPLEX
On entry, ALPHA specifies the scalar alpha.
X
(local input/local output) COMPLEX array of dimension at least ( (JX-1)*M_X + IX + ( M - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
Y
(local input/local output) COMPLEX array of dimension at least ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.
A
(local input) COMPLEX array of dimension (LLD_A, LOCq(JA+N-1))
Before entry, the leading M-by-N part of the distributed matrix sub( A ) must contain the matrix of coefficients. On exit, sub( A ) is overwritten by the updated distributed matrix.
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.

## PvHER

SUBROUTINE PvHER( UPLO, N, ALPHA, X, IX, JX, DESCX, INCX, A, IA, JA, DESCA )

Purpose

PvHER performs the Hermitian rank 1 operation

• sub( A ) := alpha*sub( X )*conjg( sub( X )' ) + sub( A ),
where sub( A ) denotes A(IA:IA+N-1,JA:JA+N-1),
```      sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
```
alpha is a real scalar, sub( X ) is an N element distributed vector and sub( A ) is an N-by-N distributed Hermitian matrix.

Arguments

UPLO
(global input) CHARACTER On entry, UPLO specifies whether the upper or lower triangular part of the distributed matrix sub( A ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of sub( A ) is to be referenced.
• UPLO = 'L' Only the lower triangular part of sub( A ) is to be referenced.
N
(global input) INTEGER
The order of the distributed matrix sub( A ). N >= 0.
ALPHA
(global input) COMPLEX
On entry, ALPHA specifies the scalar alpha.
X
(local input/local output) COMPLEX array of dimension at least ( (JX-1)*M_X + IX + ( M - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
A
(local input) COMPLEX array of dimension (LLD_A, LOCq(JA+N-1))
Before entry with UPLO = 'U', the leading N-by-N upper triangular part of the distributed matrix sub( A ) must contain the upper triangular part of the hermitian distributed matrix and the strictly lower triangular part of sub( A ) is not referenced. On exit, the upper triangular part of sub( A ) is overwritten by the upper triangular part of the updated distributed matrix.

Before entry with UPLO = 'L', the leading N-by-N lower triangular part of the distributed matrix sub( A ) must contain the lower triangular part of the hermitian distributed matrix and the strictly upper triangular part of sub( A ) is not referenced. On exit, the lower triangular part of sub( A ) is overwritten by the lower triangular part of the updated distributed matrix.

IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.

## PvHER2

SUBROUTINE PvHER2( UPLO, N, ALPHA, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY, A, IA, JA, DESCA )

Purpose

PvHER2 performs the Hermitian rank 2 operation

• sub( A ) := alpha*sub( X )*conjg( sub( Y )' ) + conjg( alpha )*sub( Y )*conjg( sub( X )' ) + sub( A ),
where sub( A ) denotes A(IA:IA+N-1,JA:JA+N-1),
```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y,
```
alpha is a scalar, sub( X ) and sub( Y ) are N element distributed vectors and sub( A ) is an N-by-N Hermitian distributed matrix.

Arguments

UPLO
(global input) CHARACTER On entry, UPLO specifies whether the upper or lower triangular part of the distributed matrix sub( A ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of sub( A ) is to be referenced.
• UPLO = 'L' Only the lower triangular part of sub( A ) is to be referenced.
N
(global input) INTEGER
The order of the distributed matrix sub( A ). N >= 0.
ALPHA
(global input) COMPLEX
On entry, ALPHA specifies the scalar alpha.
X
(local input/local output) COMPLEX array of dimension at least ( (JX-1)*M_X + IX + ( M - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
Y
(local input/local output) COMPLEX array of dimension at least ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.
A
(local input) COMPLEX array of dimension (LLD_A, LOCq(JA+N-1))
Before entry with UPLO = 'U', the leading N-by-N upper triangular part of the distributed matrix sub( A ) must contain the upper triangular part of the Hermitian distributed matrix and the strictly lower triangular part of sub( A ) is not referenced. On exit, the upper triangular part of sub( A ) is overwritten by the upper triangular part of the updated distributed matrix.

Before entry with UPLO = 'L', the leading N-by-N lower triangular part of the distributed matrix sub( A ) must contain the lower triangular part of the Hermitian distributed matrix and the strictly upper triangular part of sub( A ) is not referenced. On exit, the lower triangular part of sub( A ) is overwritten by the lower triangular part of the updated distributed matrix.

IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.

## PvSYR

SUBROUTINE PvSYR( UPLO, N, ALPHA, X, IX, JX, DESCX, INCX, A, IA, JA, DESCA )

Purpose

PvSYR performs the symmetric rank 1 operation

• sub( A ) := alpha*sub( X )*sub( X )' + sub( A ),
where sub( A ) denotes A(IA:IA+N-1,JA:JA+N-1),
```      sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
```
alpha is a real scalar, sub( X ) is an N element distributed vector and sub( A ) is an N-by-N distributed symmetric matrix.

Arguments

UPLO
(global input) CHARACTER On entry, UPLO specifies whether the upper or lower triangular part of the distributed matrix sub( A ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of sub( A ) is to be referenced.
• UPLO = 'L' Only the lower triangular part of sub( A ) is to be referenced.
N
(global input) INTEGER
The order of the distributed matrix sub( A ). N >= 0.
ALPHA
(global input) REAL
On entry, ALPHA specifies the scalar alpha.
X
(local input/local output) REAL array of dimension at least ( (JX-1)*M_X + IX + ( M - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
A
(local input) REAL array of dimension (LLD_A, LOCq(JA+N-1))
Before entry with UPLO = 'U', the leading N-by-N upper triangular part of the distributed matrix sub( A ) must contain the upper triangular part of the symmetric distributed matrix and the strictly lower triangular part of sub( A ) is not referenced. On exit, the upper triangular part of sub( A ) is overwritten by the upper triangular part of the updated distributed matrix.

Before entry with UPLO = 'L', the leading N-by-N lower triangular part of the distributed matrix sub( A ) must contain the lower triangular part of the symmetric distributed matrix and the strictly upper triangular part of sub( A ) is not referenced. On exit, the lower triangular part of sub( A ) is overwritten by the lower triangular part of the updated distributed matrix.

IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.

## PvSYR2

SUBROUTINE PvSYR2( UPLO, N, ALPHA, X, IX, JX, DESCX, INCX, Y, IY, JY, DESCY, INCY, A, IA, JA, DESCA )

Purpose

PvSYR2 performs the symmetric rank 2 operation

• sub( A ) := alpha*sub( X )*sub( Y )' + alpha*sub( Y )*sub( X )' + sub( A ) ,
where sub( A ) denotes A(IA:IA+N-1,JA:JA+N-1),
```where sub( X ) denotes X(IX,JX:JX+N-1) if INCX = M_X,
X(IX:IX+N-1,JX) if INCX = 1 and INCX <> M_X,
sub( Y ) denotes Y(IY,JY:JY+N-1) if INCY = M_Y,
Y(IY:IY+N-1,JY) if INCY = 1 and INCY <> M_Y,
```
alpha is a scalar, sub( X ) and sub( Y ) are N element distributed vectors and sub( A ) is an N-by-N symmetric distributed matrix.

Arguments

UPLO
(global input) CHARACTER On entry, UPLO specifies whether the upper or lower triangular part of the distributed matrix sub( A ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of sub( A ) is to be referenced.
• UPLO = 'L' Only the lower triangular part of sub( A ) is to be referenced.
N
(global input) INTEGER
The order of the distributed matrix sub( A ). N >= 0.
ALPHA
(global input) REAL
On entry, ALPHA specifies the scalar alpha.
X
(local input/local output) REAL array of dimension at least ( (JX-1)*M_X + IX + ( M - 1 )*abs( INCX ) )
This array contains the entries of the distributed vector sub( X ).
IX
(global input) INTEGER
The global row index of the submatrix of the distributed matrix X to operate on.
JX
(global input) INTEGER
The global column index of the submatrix of the distributed matrix X to operate on.
DESCX
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix X.
INCX
(global input) INTEGER
The global increment for the elements of X. Only two values of INCX are supported in this version, namely 1 and M_X.
Y
(local input/local output) REAL array of dimension at least ( (JY-1)*M_Y + IY + ( N - 1 )*abs( INCY ) )
This array contains the entries of the distributed vector sub( Y ).
IY
(global input) INTEGER
The global row index of the submatrix of the distributed matrix Y to operate on.
JY
(global input) INTEGER
The global column index of the submatrix of the distributed matrix Y to operate on.
DESCY
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix Y.
INCY
(global input) INTEGER
The global increment for the elements of Y. Only two values of INCY are supported in this version, namely 1 and M_Y.
A
(local input) REAL array of dimension (LLD_A, LOCq(JA+N-1))
Before entry with UPLO = 'U', the leading N-by-N upper triangular part of the distributed matrix sub( A ) must contain the upper triangular part of the symmetric distributed matrix and the strictly lower triangular part of sub( A ) is not referenced. On exit, the upper triangular part of sub( A ) is overwritten by the upper triangular part of the updated distributed matrix.

Before entry with UPLO = 'L', the leading N-by-N lower triangular part of the distributed matrix sub( A ) must contain the lower triangular part of the symmetric distributed matrix and the strictly upper triangular part of sub( A ) is not referenced. On exit, the lower triangular part of sub( A ) is overwritten by the lower triangular part of the updated distributed matrix.

IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.

## PvGEMM

SUBROUTINE PvGEMM( TRANSA, TRANSB, M, N, K, ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB, BETA, C, IC, JC, DESCC )

Purpose

PvGEMM performs one of the matrix-matrix operations

• sub( C ) := alpha*op( sub( A ) )*op( sub( B ) ) + beta*sub( C ),
where sub( C ) denotes C(IC:IC+M-1,JC:JC+N-1),
```      op( X )  is one of
op( X ) = X   or   op( X ) = X',

thus  op( sub( A ) ) denotes A(IA:IA+M-1,JA:JA+K-1)  if TRANSA = 'N',
A(IA:IA+K-1,JA:JA+M-1)' if TRANSA = 'T',
A(IA:IA+K-1,JA:JA+M-1)' if TRANSA = 'C',
op( sub( B ) ) denotes B(IB:IB+K-1,JB:JB+N-1)  if TRANSB = 'N',
B(IB:IB+N-1,JB:JB+K-1)' if TRANSB = 'T',
B(IB:IB+N-1,JB:JB+K-1)' if TRANSB = 'C',
```
alpha and beta are scalars, and sub( A ), sub( B ) and sub( C ) are distributed matrices, with op( sub( A ) ) an M-by-K distributed matrix, op( sub( B ) ) a K-by-N distributed matrix and sub( C ) an M-by-N distributed matrix.

Arguments

TRANSA
(global input) CHARACTER
The form of op( A ) to be used in the matrix multiplication as follows:
• TRANSA = 'N', op( A ) = A,
• TRANSA = 'T', op( A ) = A',
• TRANSA = 'C', op( A ) = A'.
TRANSB
(global input) CHARACTER
The form of op( B ) to be used in the matrix multiplication as follows:
• TRANSB = 'N', op( B ) = B,
• TRANSB = 'T', op( B ) = B',
• TRANSB = 'C', op( B ) = B'.
M
(global input) INTEGER
The number of rows of the distributed matrices op( sub( A ) ) and sub( C ). M >= 0.
N
(global input) INTEGER
The number of columns of the distributed matrices op( sub( B ) ) and sub( C ). N >= 0.
K
(global input) INTEGER
The number of columns of the distributed matrix op( sub( A ) ) and the number of rows of the distributed matrix op( B ). K >= 0.
ALPHA
(global input) REAL/COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) array of dimension (LLD_A, KLa)
where KLa is LOCq(JA+K-1) when TRANSA = 'N', and is LOCq(JA+M-1) otherwise. Before entry, this array must contain the local pieces of the distributed matrix sub( A ).
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
B
(local input) array of dimension (LLD_B, KLb)
where KLb is LOCq(JB+N-1) when TRANSB = 'N', and is LOCq(JB+K-1) otherwise. Before entry this array must contain the local pieces of the distributed matrix sub( B ).
IB
(global input) INTEGER
The global row index of the submatrix of the distributed matrix B to operate on.
JB
(global input) INTEGER
The global column index of the submatrix of the distributed matrix B to operate on.
DESCB
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix B.
BETA
(global input) REAL/COMPLEX
On entry, BETA specifies the scalar beta. When BETA is supplied as zero then sub( Y ) need not be set on input.
C
(local input/local output) array of dimension (LLD_C, LOCq(JC+N-1))
Before entry, this array must contain the local pieces of the distributed matrix sub( C ). On exit, the distributed matrix sub( C ) is overwritten by the M-by-N distributed matrix alpha*op( sub( A ) )*op( sub( B ) ) + beta*sub( C ).
IC
(global input) INTEGER
The global row index of the submatrix of the distributed matrix C to operate on.
JC
(global input) INTEGER
The global column index of the submatrix of the distributed matrix C to operate on.
DESCC
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix C.

## PvSYMM

SUBROUTINE PvSYMM( SIDE, UPLO, M, N, ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB, BETA, C, IC, JC, DESCC )

Purpose

PvSYMM performs one of the distributed matrix-matrix operations

• sub( C ) := alpha*sub( A )*sub( B ) + beta*sub( C ), or
• sub( C ) := alpha*sub( B )*sub( A ) + beta*sub( C ),
where sub( C ) denotes C(IC:IC+M-1,JC:JC+N-1),
```      sub( A ) denotes A(IA:IA+M-1,JA:JA+M-1)  if SIDE = 'L',
A(IA:IA+N-1,JA:JA+N-1)  if SIDE = 'R',
sub( B ) denotes B(IB:IB+M-1,JB:JB+N-1).
```
Alpha and beta are scalars, sub( A ) is a symmetric distributed matrix and sub( B ) and sub( C ) are M-by-N distributed matrices.

Arguments

SIDE
(global input) CHARACTER
On entry, SIDE specifies whether the symmetric distributed matrix sub( A ) appears on the left or right in the operation as follows:
• SIDE = 'L' sub( C ) := alpha*sub( A )*sub( B ) + beta*sub( C ),
• SIDE = 'R' sub( C ) := alpha*sub( B )*sub( A ) + beta*sub( C ),
UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the upper or lower triangular part of the symmetric distributed matrix sub( A ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of the symmetric distributed matrix is to be referenced.
• UPLO = 'L' Only the lower triangular part of the symmetric distributed matrix is to be referenced.
M
(global input) INTEGER
The number of rows to be operated on i.e., the number of rows of the distributed submatrix sub( C ). M >= 0.
N
(global input) INTEGER
The number of columns to be operated on i.e the number of columns of the distributed submatrix sub( C ). N >= 0.
ALPHA
(global input) REAL/COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) array of dimension (LLD_A, LOCq(JA+NA-1))
Before entry this array contains the local pieces of the symmetric distributed matrix sub( A ), such that when UPLO = 'U', the NA-by-NA upper triangular part of the distributed matrix sub( A ) must contain the upper triangular part of the symmetric distributed matrix and the strictly lower triangular part of sub( A ) is not referenced, and when UPLO = 'L', the NA-by-NA lower triangular part of the distributed matrix sub( A ) must contain the lower triangular part of the symmetric distributed matrix and the strictly lower triangular part of sub( A ) is not referenced.
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
B
(local input) array of dimension (LLD_B, LOCq(JB+N-1))
Before entry, this array contains the local pieces of the distributed matrix sub( B ).
IB
(global input) INTEGER
The global row index of the submatrix of the distributed matrix B to operate on.
JB
(global input) INTEGER
The global column index of the submatrix of the distributed matrix B to operate on.
DESCB
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix B.
BETA
(global input) REAL/COMPLEX
On entry, BETA specifies the scalar beta. When BETA is supplied as zero then sub( C ) need not be set on input.
C
(local input/local output) array of dimension (LLD_C, LOCq(JC+N-1))
Before entry, this array must contain the local pieces of the distributed matrix sub( C ). On exit, the distributed matrix sub( C ) is overwritten by the M-by-N updated distributed matrix.
IC
(global input) INTEGER
The global row index of the submatrix of the distributed matrix C to operate on.
JC
(global input) INTEGER
The global column index of the submatrix of the distributed matrix C to operate on.
DESCC
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix C.

## PvHEMM

SUBROUTINE PvHEMM( SIDE, UPLO, M, N, ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB, BETA, C, IC, JC, DESCC )

Purpose

PvHEMM performs one of the distributed matrix-matrix operations

• sub( C ) := alpha*sub( A )*sub( B ) + beta*sub( C ), or
• sub( C ) := alpha*sub( B )*sub( A ) + beta*sub( C ),
where sub( C ) denotes C(IC:IC+M-1,JC:JC+N-1),
```      sub( A ) denotes A(IA:IA+M-1,JA:JA+M-1)  if SIDE = 'L',
A(IA:IA+N-1,JA:JA+N-1)  if SIDE = 'R',
sub( B ) denotes B(IB:IB+M-1,JB:JB+N-1).
```
Alpha and beta are scalars, sub( A ) is a Hermitian distributed matrix and sub( B ) and sub( C ) are M-by-N distributed matrices.

Arguments

SIDE
(global input) CHARACTER
On entry, SIDE specifies whether the Hermitian distributed matrix sub( A ) appears on the left or right in the operation as follows:
• SIDE = 'L' sub( C ) := alpha*sub( A )*sub( B ) + beta*sub( C ),
• SIDE = 'R' sub( C ) := alpha*sub( B )*sub( A ) + beta*sub( C ),
UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the upper or lower triangular part of the Hermitian distributed matrix sub( A ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of the Hermitian distributed matrix is to be referenced.
• UPLO = 'L' Only the lower triangular part of the Hermitian distributed matrix is to be referenced.
M
(global input) INTEGER
The number of rows to be operated on i.e., the number of rows of the distributed submatrix sub( C ). M >= 0.
N
(global input) INTEGER
The number of columns to be operated on i.e the number of columns of the distributed submatrix sub( C ). N >= 0.
ALPHA
(global input) COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) COMPLEX array of dimension (LLD_A, LOCq(JA+NA-1))
Before entry this array contains the local pieces of the Hermitian distributed matrix sub( A ), such that when UPLO = 'U', the NA-by-NA upper triangular part of the distributed matrix sub( A ) must contain the upper triangular part of the Hermitian distributed matrix and the strictly lower triangular part of sub( A ) is not referenced, and when UPLO = 'L', the NA-by-NA lower triangular part of the distributed matrix sub( A ) must contain the lower triangular part of the Hermitian distributed matrix and the strictly lower triangular part of sub( A ) is not referenced.
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
B
(local input) COMPLEX array of dimension (LLD_B, LOCq(JB+N-1))
Before entry, this array contains the local pieces of the distributed matrix sub( B ).
IB
(global input) INTEGER
The global row index of the submatrix of the distributed matrix B to operate on.
JB
(global input) INTEGER
The global column index of the submatrix of the distributed matrix B to operate on.
DESCB
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix B.
BETA
(global input) COMPLEX
On entry, BETA specifies the scalar beta. When BETA is supplied as zero then sub( C ) need not be set on input.
C
(local input/local output) COMPLEX array of dimension (LLD_C, LOCq(JC+N-1))
Before entry, this array must contain the local pieces of the distributed matrix sub( C ). On exit, the distributed matrix sub( C ) is overwritten by the M-by-N updated distributed matrix.
IC
(global input) INTEGER
The global row index of the submatrix of the distributed matrix C to operate on.
JC
(global input) INTEGER
The global column index of the submatrix of the distributed matrix C to operate on.
DESCC
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix C.

## PvSYRK

SUBROUTINE PvSYRK( UPLO, TRANS, N, K, ALPHA, A, IA, JA, DESCA, BETA, C, IC, JC, DESCC )

Purpose

PvSYRK performs one of the symmetric rank k operations

• sub( C ) := alpha*sub( A )*sub( A )' + beta*sub( C ), or
• sub( C ) := alpha*sub( A )'*sub( A ) + beta*sub( C ),
where sub( C ) denotes C(IC:IC+N-1,JC:JC+N-1),
```      sub( A ) denotes A(IA:IA+N-1,JA:JA+K-1)  if TRANS = 'N',
A(IA:IA+K-1,JA:JA+N-1)  otherwise.
```
Alpha and beta are scalars, sub( C ) is an N-by-N symmetric distributed matrix and sub( A ) is an N-by-K distributed matrix in the first case and a K-by-N distributed matrix in the second case.

Arguments

UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the upper or lower triangular part of the distributed matrix sub( C ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of sub( C ) is to be referenced.
• UPLO = 'L' Only the lower triangular part of sub( C ) is to be referenced.
TRANS
(global input) CHARACTER
On entry, TRANS specifies the operation to be performed as follows:
• TRANS = 'N', sub( C ) := alpha*sub( A )*sub( A )' + beta*sub( C ),
• TRANS = 'T', sub( C ) := alpha*sub( A )'*sub( A ) + beta*sub( C ).
N
(global input) INTEGER
The order of the distributed matrix sub( C ). N >= 0.
K
(global input) INTEGER
On entry with TRANS = 'N', K specifies the number of columns of the distributed matrix sub( A ), and on entry with TRANS = 'T', K specifies the number of rows of the distributed matrix sub( A ). K >= 0.
ALPHA
(global input) REAL/COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) array of dimension (LLD_A, KLa)
where KLa is LOCq(JA+K-1) when TRANS = 'N', and is LOCq(JA+N-1) otherwise. Before entry with TRANS = 'N', this array contains the local pieces of the distributed matrix sub( A ).
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
BETA
(global input) REAL/COMPLEX
On entry, BETA specifies the scalar beta.
C
(local input/local output) array of dimension (LLD_C, LOCq(JC+N-1))
Before entry with UPLO = 'U', this array contains the local pieces of the N-by-N upper triangular part of the symmetric distributed matrix sub( C ) and its strictly lower triangular part is not referenced. On exit, the upper triangular part of sub( C ) is overwritten by the upper triangular part of the updated distributed matrix.

Before entry with UPLO = 'L', this array contains the local pieces of the N-by-N lower triangular part of the symmetric distributed matrix sub( C ) and its strictly upper triangular part is not referenced. On exit, the lower triangular part of sub( C ) is overwritten by the lower triangular part of the updated distributed matrix.

IC
(global input) INTEGER
The global row index of the submatrix of the distributed matrix C to operate on.
JC
(global input) INTEGER
The global column index of the submatrix of the distributed matrix C to operate on.
DESCC
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix C.

## PvHERK

SUBROUTINE PvHERK( UPLO, TRANS, N, K, ALPHA, A, IA, JA, DESCA, BETA, C, IC, JC, DESCC )

Purpose

PvHERK performs one of the Hermitian rank k operations

• sub( C ) := alpha*sub( A )*sub( A )' + beta*sub( C ), or
• sub( C ) := alpha*sub( A )'*sub( A ) + beta*sub( C ),
where sub( C ) denotes C(IC:IC+N-1,JC:JC+N-1),
```      sub( A ) denotes A(IA:IA+N-1,JA:JA+K-1)  if TRANS = 'N',
A(IA:IA+K-1,JA:JA+N-1)  otherwise.
```
Alpha and beta are scalars, sub( C ) is an N-by-N Hermitian distributed matrix and sub( A ) is an N-by-K distributed matrix in the first case and a K-by-N distributed matrix in the second case.

Arguments

UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the upper or lower triangular part of the distributed matrix sub( C ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of sub( C ) is to be referenced.
• UPLO = 'L' Only the lower triangular part of sub( C ) is to be referenced.
TRANS
(global input) CHARACTER
On entry, TRANS specifies the operation to be performed as follows:
• TRANS = 'N', sub( C ) := alpha*sub( A )*sub( A )' + beta*sub( C ),
• TRANS = 'T', sub( C ) := alpha*sub( A )'*sub( A ) + beta*sub( C ).
N
(global input) INTEGER
The order of the distributed matrix sub( C ). N >= 0.
K
(global input) INTEGER
On entry with TRANS = 'N', K specifies the number of columns of the distributed matrix sub( A ), and on entry with TRANS = 'C', K specifies the number of rows of the distributed matrix sub( A ). K >= 0.
ALPHA
(global input) COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) COMPLEX array of dimension (LLD_A, KLa)
where KLa is LOCq(JA+K-1) when TRANS = 'N', and is LOCq(JA+N-1) otherwise. Before entry with TRANS = 'N', this array contains the local pieces of the distributed matrix sub( A ).
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
BETA
(global input) COMPLEX
On entry, BETA specifies the scalar beta.
C
(local input/local output) COMPLEX array of dimension (LLD_C, LOCq(JC+N-1))
Before entry with UPLO = 'U', this array contains the local pieces of the N-by-N upper triangular part of the Hermitian distributed matrix sub( C ) and its strictly lower triangular part is not referenced. On exit, the upper triangular part of sub( C ) is overwritten by the upper triangular part of the updated distributed matrix.

Before entry with UPLO = 'L', this array contains the local pieces of the N-by-N lower triangular part of the Hermitian distributed matrix sub( C ) and its strictly upper triangular part is not referenced. On exit, the lower triangular part of sub( C ) is overwritten by the lower triangular part of the updated distributed matrix.

IC
(global input) INTEGER
The global row index of the submatrix of the distributed matrix C to operate on.
JC
(global input) INTEGER
The global column index of the submatrix of the distributed matrix C to operate on.
DESCC
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix C.

## PvSYR2K

SUBROUTINE PvSYR2K( UPLO, TRANS, N, K, ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB, BETA, C, IC, JC, DESCC )

Purpose

PvSYR2K performs one of the symmetric rank 2k operations

• sub( C ) := alpha*sub( A )*sub( B )' + alpha*sub( B )*sub( A )' + beta*sub( C ), or
• sub( C ) := alpha*sub( A )'*sub( B ) + alpha*sub( B )'*sub( A ) + beta*sub( C ),
where sub( C ) denotes C(IC:IC+N-1,JC:JC+N-1),
```      sub( A ) denotes A(IA:IA+N-1,JA:JA+K-1)  if TRANS = 'N',
A(IA:IA+K-1,JA:JA+N-1)  otherwise,

sub( B ) denotes B(IB:IB+N-1,JB:JB+K-1)  if TRANS = 'N',
B(IB:IB+K-1,JB:JB+N-1)  otherwise.
```
Alpha and beta are scalars, sub( C ) is an N-by-N symmetric distributed matrix and sub( A ) and sub( B ) are N-by-K distributed matrices in the first case and a K-by-N distributed matrices in the second case.

Arguments

UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the upper or lower triangular part of the distributed matrix sub( C ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of sub( C ) is to be referenced.
• UPLO = 'L' Only the lower triangular part of sub( C ) is to be referenced.
TRANS
(global input) CHARACTER
On entry, TRANS specifies the operation to be performed as follows:
• TRANS = 'N', sub( C ) := alpha*sub( A )*sub( B )' + alpha*sub( B )*sub( A )' + beta*sub( C ),
• TRANS = 'T', sub( C ) := alpha*sub( B )'*sub( A ) + alpha*sub( A )'*sub( B ) + beta*sub( C ).
N
(global input) INTEGER
The order of the distributed matrix sub( C ). N >= 0.
K
(global input) INTEGER
On entry with TRANS = 'N', K specifies the number of columns of the distributed matrices sub( A ) and sub( B ), and on entry with TRANS = 'T', K specifies the number of rows of the distributed matrices sub( A ) and sub( B ). K >= 0.
ALPHA
(global input) REAL/COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) array of dimension (LLD_A, KLa)
where KLa is LOCq(JA+K-1) when TRANS = 'N', and is LOCq(JA+N-1) otherwise. Before entry with TRANS = 'N', this array contains the local pieces of the distributed matrix sub( A ).
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
B
(local input) array of dimension (LLD_B, KLb)
where KLb is LOCq(JB+K-1) when TRANS = 'N', and is LOCq(JB+N-1) otherwise. Before entry with TRANS = 'N', this array contains the local pieces of the distributed matrix sub( B ).
IB
(global input) INTEGER
The global row index of the submatrix of the distributed matrix B to operate on.
JB
(global input) INTEGER
The global column index of the submatrix of the distributed matrix B to operate on.
DESCB
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix B.
BETA
(global input) REAL/COMPLEX
On entry, BETA specifies the scalar beta.
C
(local input/local output) array of dimension (LLD_C, LOCq(JC+N-1))
Before entry with UPLO = 'U', this array contains the local pieces of the N-by-N upper triangular part of the symmetric distributed matrix sub( C ) and its strictly lower triangular part is not referenced. On exit, the upper triangular part of sub( C ) is overwritten by the upper triangular part of the updated distributed matrix.

Before entry with UPLO = 'L', this array contains the local pieces of the N-by-N lower triangular part of the symmetric distributed matrix sub( C ) and its strictly upper triangular part is not referenced. On exit, the lower triangular part of sub( C ) is overwritten by the lower triangular part of the updated distributed matrix.

IC
(global input) INTEGER
The global row index of the submatrix of the distributed matrix C to operate on.
JC
(global input) INTEGER
The global column index of the submatrix of the distributed matrix C to operate on.
DESCC
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix C.

## PvHER2K

SUBROUTINE PvHER2K( UPLO, TRANS, N, K, ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB, BETA, C, IC, JC, DESCC )

Purpose

PvHER2K performs one of the Hermitian rank 2k operations

• sub( C ) := alpha*sub( A )*conjg( sub( B ) )' + conjg( alpha )*sub( B )*conjg( sub( A ) )' + beta*sub( C ), or
• sub( C ) := alpha*conjg( sub( A )' )*sub( B ) + conjg( alpha )*conjg( sub( B )' )*sub( A ) + beta*sub( C ),
where sub( C ) denotes C(IC:IC+N-1,JC:JC+N-1),
```      sub( A ) denotes A(IA:IA+N-1,JA:JA+K-1)  if TRANS = 'N',
A(IA:IA+K-1,JA:JA+N-1)  otherwise,

sub( B ) denotes B(IB:IB+N-1,JB:JB+K-1)  if TRANS = 'N',
B(IB:IB+K-1,JB:JB+N-1)  otherwise.
```
Alpha and beta are scalars with beta real, sub( C ) is an N-by-N Hermitian distributed matrix and sub( A ) and sub( B ) are N-by-K distributed matrices in the first case and a K-by-N distributed matrices in the second case.

Arguments

UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the upper or lower triangular part of the distributed matrix sub( C ) is to be referenced as follows:
• UPLO = 'U' Only the upper triangular part of sub( C ) is to be referenced.
• UPLO = 'L' Only the lower triangular part of sub( C ) is to be referenced.
TRANS
(global input) CHARACTER
On entry, TRANS specifies the operation to be performed as follows:
• TRANS = 'N', sub( C ) := alpha*sub( A )*conjg( sub( B )' ) + conjg( alpha )*sub( B )*conjg( sub( A )' ) + beta*C,
• TRANS = 'C', sub( C ) := alpha*conjg( sub( A )' )*sub( B ) + conjg( alpha )*conjg( sub( B )' )*sub( A ) + beta*sub( C ).
N
(global input) INTEGER
The order of the distributed matrix sub( C ). N >= 0.
K
(global input) INTEGER
On entry with TRANS = 'N', K specifies the number of columns of the distributed matrices sub( A ) and sub( B ), and on entry with TRANS = 'C', K specifies the number of rows of the distributed matrices sub( A ) and sub( B ). K >= 0.
ALPHA
(global input) COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) COMPLEX array of dimension (LLD_A, KLa)
where KLa is LOCq(JA+K-1) when TRANS = 'N', and is LOCq(JA+N-1) otherwise. Before entry with TRANS = 'N', this array contains the local pieces of the distributed matrix sub( A ).
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
B
(local input) COMPLEX array of dimension (LLD_B, KLb)
where KLb is LOCq(JB+K-1) when TRANS = 'N', and is LOCq(JB+N-1) otherwise. Before entry with TRANS = 'N', this array contains the local pieces of the distributed matrix sub( B ).
IB
(global input) INTEGER
The global row index of the submatrix of the distributed matrix B to operate on.
JB
(global input) INTEGER
The global column index of the submatrix of the distributed matrix B to operate on.
DESCB
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix B.
BETA
(global input) COMPLEX
On entry, BETA specifies the scalar beta.
C
(local input/local output) COMPLEX array of dimension (LLD_C, LOCq(JC+N-1))
Before entry with UPLO = 'U', this array contains the local pieces of the N-by-N upper triangular part of the symmetric distributed matrix sub( C ) and its strictly lower triangular part is not referenced. On exit, the upper triangular part of sub( C ) is overwritten by the upper triangular part of the updated distributed matrix.

Before entry with UPLO = 'L', this array contains the local pieces of the N-by-N lower triangular part of the symmetric distributed matrix sub( C ) and its strictly upper triangular part is not referenced. On exit, the lower triangular part of sub( C ) is overwritten by the lower triangular part of the updated distributed matrix.

IC
(global input) INTEGER
The global row index of the submatrix of the distributed matrix C to operate on.
JC
(global input) INTEGER
The global column index of the submatrix of the distributed matrix C to operate on.
DESCC
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix C.

## PvTRAN

SUBROUTINE PvTRAN( M, N, ALPHA, A, IA, JA, DESCA, BETA, C, IC, JC, DESCC )

Purpose

PvTRAN transposes a distributed matrix

• sub( C ) = beta * sub( C ) + alpha * op( sub( A ) )
where sub( C ) denotes C(IC:IC+M-1,JC:JC+N-1),
```      sub( A ) denotes A(IA:IA+N-1,JA:JA+M-1),
op( A )  denotes A**T.
```
Beta is a scalar, sub( C ) is an M-by-N distributed matrix, sub( A ) is an N-by-M distributed matrix.

Arguments

M
(global input) INTEGER
The number of rows to be operated on i.e., the number of rows of the distributed submatrix sub( C ). M >= 0.
N
(global input) INTEGER
The number of columns to be operated on i.e the number of columns of the distributed submatrix sub( C ). N >= 0.
ALPHA
(global input) REAL
On entry, ALPHA specifies the scalar alpha.
A
(local input) REAL array of dimension (LLD_A, LOCq(JA+M-1))
This array contains the local pieces of the distributed matrix sub( A ).
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
BETA
(global input) REAL
On entry, BETA specifies the scalar beta. When BETA is supplied as zero then sub( C ) need not be set on input.
C
(local input/local output) array of dimension (LLD_C, LOCq(JC+N-1))
This array contains the local pieces of the distributed matrix sub( C ). On exit, the distributed matrix sub( C ) is over- written by the updated matrix.
IC
(global input) INTEGER
The global row index of the submatrix of the distributed matrix C to operate on.
JC
(global input) INTEGER
The global column index of the submatrix of the distributed matrix C to operate on.
DESCC
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix C.

## PvTRANU

SUBROUTINE PvTRANU( M, N, ALPHA, A, IA, JA, DESCA, BETA, C, IC, JC, DESCC )

Purpose

PvTRANU transposes a distributed matrix

• sub( C ) = beta * sub( C ) + alpha * op( sub( A ) )
where sub( C ) denotes C(IC:IC+M-1,JC:JC+N-1),
```      sub( A ) denotes A(IA:IA+N-1,JA:JA+M-1),
op( A )  denotes A**T.
```
Beta is a scalar, sub( C ) is an M-by-N distributed matrix, sub( A ) is an N-by-M distributed matrix.

Arguments

M
(global input) INTEGER
The number of rows to be operated on i.e., the number of rows of the distributed submatrix sub( C ). M >= 0.
N
(global input) INTEGER
The number of columns to be operated on i.e the number of columns of the distributed submatrix sub( C ). N >= 0.
ALPHA
(global input) COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) COMPLEX array of dimension (LLD_A, LOCq(JA+M-1))
This array contains the local pieces of the distributed matrix sub( A ).
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
BETA
(global input) COMPLEX
On entry, BETA specifies the scalar beta. When BETA is supplied as zero then sub( C ) need not be set on input.
C
(local input/local output) COMPLEX array of dimension (LLD_C, LOCq(JC+N-1))
This array contains the local pieces of the distributed matrix sub( C ). On exit, the distributed matrix sub( C ) is over- written by the updated matrix.
IC
(global input) INTEGER
The global row index of the submatrix of the distributed matrix C to operate on.
JC
(global input) INTEGER
The global column index of the submatrix of the distributed matrix C to operate on.
DESCC
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix C.

## PvTRANC

SUBROUTINE PvTRANC( M, N, ALPHA, A, IA, JA, DESCA, BETA, C, IC, JC, DESCC )

Purpose

PvTRANC transposes a distributed matrix

• sub( C ) = beta * sub( C ) + alpha * op( sub( A ) )
where sub( C ) denotes C(IC:IC+M-1,JC:JC+N-1),
```      sub( A ) denotes A(IA:IA+N-1,JA:JA+M-1),
op( A )  denotes A**H.
```
Beta is a scalar, sub( C ) is an M-by-N distributed matrix, sub( A ) is an N-by-M distributed matrix.

Arguments

M
(global input) INTEGER
The number of rows to be operated on i.e., the number of rows of the distributed submatrix sub( C ). M >= 0.
N
(global input) INTEGER
The number of columns to be operated on i.e the number of columns of the distributed submatrix sub( C ). N >= 0.
ALPHA
(global input) COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) COMPLEX array of dimension (LLD_A, LOCq(JA+M-1))
This array contains the local pieces of the distributed matrix sub( A ).
IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
BETA
(global input) COMPLEX
On entry, BETA specifies the scalar beta. When BETA is supplied as zero then sub( C ) need not be set on input.
C
(local input/local output) COMPLEX array of dimension (LLD_C, LOCq(JC+N-1))
This array contains the local pieces of the distributed matrix sub( C ). On exit, the distributed matrix sub( C ) is over- written by the updated matrix.
IC
(global input) INTEGER
The global row index of the submatrix of the distributed matrix C to operate on.
JC
(global input) INTEGER
The global column index of the submatrix of the distributed matrix C to operate on.
DESCC
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix C.

## PvTRMM

SUBROUTINE PvTRMM( SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB )

Purpose

PvTRMM performs one of the distributed matrix-matrix operations

• sub( B ) := alpha*op( sub( A ) )*sub( B ),
where sub( A ) denotes A(IA:IA+M-1,JA:JA+M-1) if SIDE = 'L',
```      sub( A ) denotes A(IA:IA+N-1,JA:JA+N-1)  if SIDE = 'R',
sub( B ) denotes B(IB:IB+M-1,JB:JB+N-1),
```
alpha is a scalar, sub( B ) is an M-by-N distributed matrix, sub( A ) is a unit, or non-unit, upper or lower triangular distributed matrix and op( A ) is one of
• op( A ) = A or op( A ) = A'.
Arguments

SIDE
(global input) CHARACTER
On entry, SIDE specifies whether op( sub( A ) ) multiplies sub( B ) from the left or right as follows:
• SIDE = 'L', sub( B ) := alpha*op( sub( A ) )*sub( B ),
• SIDE = 'R', sub( B ) := alpha*sub( B )*op( sub( A ) ).
UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the distributed matrix sub( A ) is an upper or lower triangular distributed matrix as follows:
• UPLO = 'U', sub( A ) is an upper triangular distributed matrix,
• UPLO = 'L', sub( A ) is a lower triangular distributed matrix.
TRANSA
(global input) CHARACTER
The form of op( A ) to be used in the matrix multiplication as follows:
• TRANSA = 'N', op( A ) = A,
• TRANSA = 'T', op( A ) = A',
• TRANSA = 'C', op( A ) = A'.
DIAG
(global input) CHARACTER
On entry, DIAG specifies whether or not sub( A ) is unit triangular as follows:
• DIAG = 'U', sub( A ) is assumed to be unit triangular,
• DIAG = 'N', sub( A ) is not assumed to be unit triangular.
M
(global input) INTEGER
The number of rows to be operated on i.e., the number of rows of the distributed submatrix sub( B ). M >= 0.
N
(global input) INTEGER
The number of columns to be operated on i.e the number of columns of the distributed submatrix sub( B ). N >= 0.
ALPHA
(global input) REAL/COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) array of dimension (LLD_A, LOCq(JA+NA-1)
Before entry with UPLO = 'U', the leading NA-by-NA upper triangular part of the distributed matrix sub( A ) must contain the local pieces of the upper triangular distributed matrix and its strictly lower triangular part is not referenced.

Before entry with UPLO = 'L', the leading NA-by-NA lower triangular part of the distributed matrix sub( A ) must contain the lower triangular distributed matrix and its strictly upper triangular part is not referenced. Note that when DIAG = 'U', the diagonal elements of sub( A ) are not referenced either, but are assumed to be unity.

IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
B
(local input) array of dimension (LLD_B, LOCq(JB+N-1))
Before entry, this array contains the local pieces of the distributed matrix sub( B ). On exit, sub( B ) is overwritten by the transformed distributed matrix.
IB
(global input) INTEGER
The global row index of the submatrix of the distributed matrix B to operate on.
JB
(global input) INTEGER
The global column index of the submatrix of the distributed matrix B to operate on.
DESCB
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix B.

## PvTRSM

SUBROUTINE PvTRSM( SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, IA, JA, DESCA, B, IB, JB, DESCB )

Purpose

PvTRSM solves one of the distributed matrix equations

• op( sub( A ) )*X = alpha*sub( B ), or
• X*op( sub( A ) ) = alpha*sub( B ),
where sub( A ) denotes A(IA:IA+M-1,JA:JA+M-1) if SIDE = 'L',
```      sub( A ) denotes A(IA:IA+N-1,JA:JA+N-1)  if SIDE = 'R',
sub( B ) denotes B(IB:IB+M-1,JB:JB+N-1),
```
alpha is a scalar, X and sub( B ) are an M-by-N distributed matrix, sub( A ) is a unit, or non-unit, upper or lower triangular distributed matrix and op( A ) is one of
• op( A ) = A or op( A ) = A'.
The distributed matrix X is overwritten on sub( B ). Arguments

SIDE
(global input) CHARACTER
On entry, SIDE specifies whether op( A ) appears on the left or right of X as follows:
• SIDE = 'L', op( sub( A ) )*X = alpha*sub( B ),
• SIDE = 'R', X*op( sub( A ) ) = alpha*sub( B ).
UPLO
(global input) CHARACTER
On entry, UPLO specifies whether the distributed matrix sub( A ) is an upper or lower triangular distributed matrix as follows:
• UPLO = 'U', sub( A ) is an upper triangular distributed matrix,
• UPLO = 'L', sub( A ) is a lower triangular distributed matrix.
TRANSA
(global input) CHARACTER
The form of op( A ) to be used in the matrix multiplication as follows:
• TRANSA = 'N', op( A ) = A,
• TRANSA = 'T', op( A ) = A',
• TRANSA = 'C', op( A ) = A'.
DIAG
(global input) CHARACTER
On entry, DIAG specifies whether or not sub( A ) is unit triangular as follows:
• DIAG = 'U', sub( A ) is assumed to be unit triangular,
• DIAG = 'N', sub( A ) is not assumed to be unit triangular.
M
(global input) INTEGER
The number of rows to be operated on i.e., the number of rows of the distributed submatrix sub( B ). M >= 0.
N
(global input) INTEGER
The number of columns to be operated on i.e., the number of columns of the distributed submatrix sub( B ). N >= 0.
ALPHA
(global input) REAL/COMPLEX
On entry, ALPHA specifies the scalar alpha.
A
(local input) array of dimension (LLD_A, LOCq(JA+NA-1)
Before entry with UPLO = 'U', the leading NA-by-NA upper triangular part of the distributed matrix sub( A ) must contain the local pieces of the upper triangular distributed matrix and its strictly lower triangular part is not referenced.

Before entry with UPLO = 'L', the leading NA-by-NA lower triangular part of the distributed matrix sub( A ) must contain the lower triangular distributed matrix and its strictly upper triangular part is not referenced. Note that when DIAG = 'U', the diagonal elements of sub( A ) are not referenced either, but are assumed to be unity.

IA
(global input) INTEGER
The global row index of the submatrix of the distributed matrix A to operate on.
JA
(global input) INTEGER
The global column index of the submatrix of the distributed matrix A to operate on.
DESCA
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix A.
B
(local input) array of dimension (LLD_B, LOCq(JB+N-1))
Before entry, this array contains the local pieces of the distributed matrix sub( B ). On exit, sub( B ) is overwritten by the solution distributed matrix.
IB
(global input) INTEGER
The global row index of the submatrix of the distributed matrix B to operate on.
JB
(global input) INTEGER
The global column index of the submatrix of the distributed matrix B to operate on.
DESCB
(global and local input) INTEGER array of dimension 8
The array descriptor of the distributed matrix B.