PLASMA 2.8.0 PLASMA - Parallel Linear Algebra for Scalable Multi-core Architectures

- Main Page
- Modules
- Data Types List

int CORE_spamm | ( | int | op,
|  | PLASMA_enum | side,
|  | PLASMA_enum | storev,
|  | int | M,
|  | int | N,
|  | int | K,
|  | int | L,
|  | const float * | A1,
|  | int | LDA1,
|  | float * | A2,
|  | int | LDA2,
|  | const float * | V,
|  | int | LDV,
|  | float * | W,
|  | int | LDW
| ) |  |

ZPAMM performs one of the matrix-matrix operations

                  LEFT                      RIGHT

OP PlasmaW : W = A1 + op(V) * A2 or W = A1 + A2 * op(V) OP PlasmaA2 : A2 = A2 - op(V) * W or A2 = A2 - W * op(V)

where op( V ) is one of

op( V ) = V or op( V ) = V**T or op( V ) = V**T,

A1, A2 and W are general matrices, and V is:

      l = k: rectangle + triangle
      l < k: rectangle + trapezoid
      l = 0: rectangle

Size of V, both rowwise and columnwise, is:

## side trans size

left N M x K T K x M right N K x N

## T N x K

LEFT (columnwise and rowwise):

            |    K    |                 |         M         |
         _  __________   _              _______________        _
            |    |    |                 |             | \

V: | | | V': |_____________|___\ K | | | M-L | | M | | | |__________________| _ |____| | _ \ | | | M - L | L | \ | | L _ |____| _

RIGHT (columnwise and rowwise):

        |         K         |                   |    N    |
        _______________        _             _  __________   _
        |             | \                       |    |    |

V': |_____________|___\ N V: | | | | | | | | K-L |__________________| _ K | | | |____| | _ | K - L | L | \ | | \ | | L _ |____| _

# Arguments

Parameters

  [in] | op |
          OP specifies which operation to perform:

          @arg PlasmaW  : W  = A1 + op(V) * A2  or  W  = A1 + A2 * op(V)
          @arg PlasmaA2 : A2 = A2 - op(V) * W   or  A2 = A2 - W * op(V)
  [in] | side |
          SIDE specifies whether  op( V ) multiplies A2
          or W from the left or right as follows:

          @arg PlasmaLeft  : multiply op( V ) from the left
                             OP PlasmaW  :  W  = A1 + op(V) * A2
                             OP PlasmaA2 :  A2 = A2 - op(V) * W

          @arg PlasmaRight : multiply op( V ) from the right
                             OP PlasmaW  :  W  = A1 + A2 * op(V)
                             OP PlasmaA2 :  A2 = A2 - W * op(V)
  [in] | storev |
          Indicates how the vectors which define the elementary
          reflectors are stored in V:

          @arg PlasmaColumnwise
          @arg PlasmaRowwise
  [in] | M | The number of rows of the A1, A2 and W If SIDE is PlasmaLeft, the number of rows of op( V )
  [in] | N | The number of columns of the A1, A2 and W If SIDE is PlasmaRight, the number of columns of op( V )
  [in] | K | If SIDE is PlasmaLeft, the number of columns of op( V ) If SIDE is PlasmaRight, the number of rows of op( V )
  [in] | L | The size of the triangular part of V
  [in] | A1 | On entry, the M-by-N tile A1.
  [in] | LDA1 | The leading dimension of the array A1. LDA1 >= max(1,M).
  [in,out] | A2 | On entry, the M-by-N tile A2. On exit, if OP is PlasmaA2 A2 is overwritten
  [in] | LDA2 | The leading dimension of the tile A2. LDA2 >= max(1,M).
  [in] | V | The matrix V as described above. If SIDE is PlasmaLeft : op( V ) is M-by-K If SIDE is PlasmaRight: op( V ) is K-by-N
  [in] | LDV | The leading dimension of the array V.
  [in,out] | W | On entry, the M-by-N matrix W. On exit, W is overwritten either if OP is PlasmaA2 or PlasmaW. If OP is PlasmaA2, W is an input and is used as a workspace.
  [in] | LDW | The leading dimension of array WORK.

Returns

Return values

  PLASMA_SUCCESS | successful exit
  <0 | if -i, the i-th argument had an illegal value