syr(3F)

NAME
     dsyr, ssyr, zher, cher - BLAS Level Two   (Symmetric/Hermitian)Matrix
     Rank 1 Update


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

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

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

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



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

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

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

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



DESCRIPTION
     dsyr and ssyr perform the symmetric rank 1 operation

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

     zher and cher perform the hermitian rank 1 operation

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

     where alpha is a real/complex scalar, x is an n element vector 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.

     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.