# Name

**HPL_dger** A := alpha * x * y^T + A.
# Synopsis

`#include "hpl.h"`

`void`

`HPL_dger(`

`const enum HPL_ORDER`

`ORDER`

,
`const int`

`M`

,
`const int`

`N`

,
`const double`

`ALPHA`

,
`const double *`

`X`

,
`const int`

`INCX`

,
`double *`

`Y`

,
`const int`

`INCY`

,
`double *`

`A`

,
`const int`

`LDA`

`);`

# Description

**HPL_dger**
performs the rank 1 operation
A := alpha * x * y^T + A,
where alpha is a scalar, x is an m-element vector, y is an n-element
vector and A is an m by n matrix.
# Arguments

ORDER (local input) const enum HPL_ORDER
On entry, ORDER specifies the storage format of the operands
as follows:
ORDER = HplRowMajor,
ORDER = HplColumnMajor.

M (local input) const int
On entry, M specifies the number of rows of the matrix A.
M must be at least zero.

N (local input) const int
On entry, N specifies the number of columns of the matrix A.
N must be at least zero.

ALPHA (local input) const double
On entry, ALPHA specifies the scalar alpha. When ALPHA is
supplied as zero then X and Y need not be set on input.

X (local input) const double *
On entry, X is an incremented array of dimension at least
( 1 + ( m - 1 ) * abs( INCX ) ) that contains the vector x.

INCX (local input) const int
On entry, INCX specifies the increment for the elements of X.
INCX must not be zero.

Y (local input) double *
On entry, Y is an incremented array of dimension at least
( 1 + ( n - 1 ) * abs( INCY ) ) that contains the vector y.

INCY (local input) const int
On entry, INCY specifies the increment for the elements of Y.
INCY must not be zero.

A (local input/output) double *
On entry, A points to an array of size equal to or greater
than LDA * n. Before entry, the leading m by n part of the
array A must contain the matrix coefficients. On exit, A is
overwritten by the updated matrix.

LDA (local input) const int
On entry, LDA specifies the leading dimension of A as
declared in the calling (sub) program. LDA must be at
least MAX(1,m).

# Example

`#include "hpl.h"`

int main(int argc, char *argv[])
{
double a[2*2], x[2], y[2];
a[0] = 1.0; a[1] = 2.0; a[2] = 3.0; a[3] = 3.0;
x[0] = 2.0; x[1] = 1.0; y[2] = 1.0; y[3] = 2.0;
HPL_dger( HplColumnMajor, 2, 2, 2.0, x, 1, y, 1,
a, 2 );
printf("y=[%f,%f]\n", y[0], y[1]);
exit(0); return(0);
}

# See Also

HPL_dgemv,
HPL_dtrsv.