syr2(3F)

NAME
     dsyr2, ssyr2, zher2, cher2 - BLAS Level Two
     (Symmetric/Hermitian)Matrix Rank 2 Update


FORTRAN 77 SYNOPSIS
     subroutine dsyr2( uplo, n, alpha, x, incx, y, incy, a, lda )
           character*1        uplo
           integer            n, incx, incy, lda
           double precision   alpha
           double precision   a( lda,*), x(*), y(*)

     subroutine ssyr2( uplo, n, alpha, x, incx, y, incy, a, lda)
           character*1        uplo
           integer            n, incx, incy, lda
           real               alpha
           real               a( lda,*), x(*), y(*)

     subroutine zher2( uplo, n, alpha, x, incx, y, incy, a, lda)
           character*1        uplo
           integer            n, incx, incy, lda
           complex*16         alpha
           complex*16         a( lda,*), x(*), y(*)

     subroutine cher2( uplo, n, alpha, x, incx, y, incy, a, lda)
           character*1        uplo
           integer            n, incx, incy, lda
           complex            alpha
           complex            a( lda,*), x(*), y(*)



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

     void ssyr2( uplo, n, alpha, x, incx, y, incy, a, lda )
           MatrixTriangle     uplo;
           Integer            n, incx, incy, lda;
           float              alpha
           float              (*a)[lda*n], (*x)[ n ], (*y)[ n ];

     void zher2( uplo, n, alpha, x, incx, y, incy, a, lda )
           MatrixTriangle     uplo;
           Integer            n, incx, incy, lda;
           Zomplex            alpha
           Zomplex            (*a)[lda*n], (*x)[ n ], (*y)[ n ];

     void cher2( uplo, n, alpha, x, incx, y, incy, a, lda )
           MatrixTriangle     uplo;
           Integer            n, incx, incy, lda;
           Complex            alpha
           Complex            (*a)[lda*n], (*x)[ n ], (*y)[ n ];



DESCRIPTION
     dsyr2 and ssyr2 perform the symmetric rank 2 operation

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

     zher2 and cher2 perform the hermitian rank 2 operation

           A := alpha*x*conjg( y' ) + conjg( alpha )*y*conjg( x' ) + A,

     where alpha is a scalar, x and y are n element vectors and A is an n by n
     symmetric/hermitian matrix.


PARAMETERS
     uplo    On entry, uplo specifies whether the upper or lower triangular
             part of the array A is to be referenced a follows:



             FORTRAN
             uplo = 'U' or 'u'   Only the upper triangular part of A
                                 is to be referenced.
             uplo = 'L' or 'l'   Only the lower triangular part of A
                                 is to be referenced.

             C
             uplo = UpperTriangle     Only the lower triangular part of A
                                      is to be referenced.
             uplo = LowerTriangle     Only the lower triangular part of A
                                      is to be referenced.

             Unchanged on exit.

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

     alpha   specifies the scalar alpha.
             Unchanged on exit.

     x       Array of size at least ( 1 + ( n - 1 )*abs( incx ) ). Before
             entry, the incremented array x must contain the n 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. On exit, Y is overwritten by the updated vector y.

     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 with uplo = 'U' or 'u' or , the array elements
             corresponding to the leading n by n upper triangular part of the
             matrix A must contain the uppertriangular part of the
             symmetric/hermitian matrix and the corresponding strictly lower
             triangular part of A is not referenced. On exit, the array
             elements corresponding to the upper triangular part of the matrix
             A is overwritten by the upper triangular part of the updated
             matrix.

             Before entry with uplo = 'L' or 'l' or , the array elements
             corresponding to the leading n by n lower triangular part of the
             matrix A must contain the lower triangular part of the
             symmetric/hermitian matrix and the corresponding strictly upper
             triangular part of A is not referenced. On exit, the array
             elements corresponding to the lower triangular part of the matrix
             A is overwritten by the lower triangular part of the updated
             matrix.

             Note that the imaginary parts of the diagonal elements need not
             be set and are assumed to be zero.

     lda     On entry, lda specifies the first dimension of A as declared in
             the calling (sub) program. lda must be at least ( k + 1 ).
             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.