ger(3F)

NAME
     dger, sger, zgeru, cgeru, zgerc, cgerc - BLAS Level Two   Rank 1
     Operation


FORTRAN 77 SYNOPSIS
     subroutine dger( m, n, alpha, x, incx, y, incy, a, lda )
           integer            m, n, lda, incx, incy
           double precision   alpha
           double precision   a( lda,*), x(*), y(*)

     subroutine sger( m, n, alpha, x, incx, y, incy, a, lda )
           integer            m, n, lda, incx, incy
           real               alpha
           real               a( lda,*), x(*), y(*)

     subroutine zgeru( m, n, alpha, x, incx, y, incy, a, lda )
           integer            m, n, lda, incx, incy
           complex*16         alpha
           complex*16         a( lda,*), x(*), y(*)

     subroutine cgeru( m, n, alpha, x, incx, y, incy, a, lda )
           integer            m, n, lda, incx, incy
           complex            alpha
           complex            a( lda,*), x(*), y(*)

     subroutine zgerc( m, n, alpha, x, incx, y, incy, a, lda )
           integer            m, n, lda, incx, incy
           complex*16         alpha
           complex*16         a( lda,*), x(*), y(*)

     subroutine cgerc( m, n, alpha, x, incx, y, incy, a, lda )
           integer            m, n, lda, incx, incy
           complex            alpha
           complex            a( lda,*), x(*), y(*)


C SYNOPSIS
     void dger( m, n, alpha, x, incx, y, incy, a, lda )
           Integer            m, n, lda, incx, incy;
           double             alpha;
           double             (*a)[lda*n], (*x)[ n ], (*y)[ n ];

     void sger( m, n, alpha, x, incx, y, incy, a, lda )
           Integer            m, n, lda, incx, incy;
           float              alpha;
           float              (*a)[lda*n], (*x)[ n ], (*y)[ n ];

     void zgeru( m, n, alpha, x, incx, y, incy, a, lda )
           Integer            m, n, lda, incx, incy;
           Zomplex            alpha;
           Zomplex            (*a)[lda*n], (*x)[ n ], (*y)[ n ];
     void cgeru( m, n, alpha, x, incx, y, incy, a, lda )
           Integer            m, n, lda, incx, incy;
           Complex            alpha;
           Complex            (*a)[lda*n], (*x)[ n ], (*y)[ n ];

     void zherc( m, n, alpha, x, incx, y, incy, a, lda )
           Integer            m, n, lda, incx, incy;
           Zomplex            alpha;
           Zomplex            (*a)[lda*n], (*x)[ n ], (*y)[ n ];

     void cgerc( m, n, alpha, x, incx, y, incy, a, lda )
           Integer            m, n, lda, incx, incy;
           Complex            alpha;
           Complex            (*a)[lda*n], (*x)[ n ], (*y)[ n ];



DESCRIPTION
     dger , sger , zheru and cgeru perform the rank 1 operation

           A := alpha*x*y' + A,

     zgerc and cgerc perform the rank 1 operation

           A := alpha*x*conjg( y' ) + 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.


PARAMETERS
     m       On entry, m specifies the number of rows of the matrix A.  m must
             be at least zero.
             Unchanged on exit.

     n       On entry, n specifies the number of columns of the matrix A.  n
             must be at least zero.
             Unchanged on exit.

     alpha   On entry, alpha specifies the scalar alpha.
             Unchanged on exit.

     x       Array of size at least ( 1 + ( m - 1 )*abs( incx ) ). Before
             entry, the incremented array x must contain the m element vector
             x.
             Unchanged on exit.

     incx    On entry, incx specifies the increment for the elements of x.
             incx must not be zero.
             Unchanged on exit.

     y       Array of size at least ( 1 + ( n - 1 )*abs( incy ) ). Before
             entry, the incremented array y must contain the n element vector
             y.
             Unchanged on exit.

     incy    On entry, incy specifies the increment for the elements of y.
             incy must not be zero.
             Unchanged on exit.

     a       An array containing the matrix A.

             FORTRAN
             Array of dimension ( lda, n ).

             C
             A pointer to an array of size lda*n.
             See note below about array storage convention for C.

             Before entry, the leading m by n part of the array A must contain
             the matrix of coefficients.  On exit, A is overwritten by the
             updated matrix.

     lda     On entry, lda specifies the first dimension of a as declared in
             the calling (sub) program.  lda must be at least max( 1, m ).
             Unchanged on exit.


C ARRAY STORAGE CONVENTION
       The matrices  are assumed  to be stored in a  one dimensional C array
       in an analogous fashion as a Fortran array (column major). Therefore,
       the element  A(i+1,j)  of matrix A  is stored  immediately  after the
       element  A(i,j), while  A(i,j+1) is lda  elements apart from  A(i,j).
       The element A(i,j) of the matrix can be accessed directly by reference
       to  a[ (j-1)*lda + (i-1) ].


AUTHORS
          Jack Dongarra, Argonne National Laboratory.
          Iain Duff, AERE Harwell.
          Jeremy Du Croz, Numerical Algorithms Group Ltd.
          Sven Hammarling, Numerical Algorithms Group Ltd.


TUNING
          Optimized and parallelized for SGI R3000, R4x00 and R8000 platforms.