syr2k(3F)

NAME
     dsyr2k, ssyr2k, zsyr2k, csyr2k - BLAS level three  Symmetric Rank 2K
     Update.


FORTRAN 77 SYNOPSIS
     subroutine dsyr2k(uplo,trans,n,k,alpha,a,lda,b,ldb,beta,c,ldc)
           character*1        uplo, trans
           integer            n, k, lda, ldb, ldc
           double precision   alpha, beta
           double precision   a( lda,*), b( ldb,*), c(ldc,*)

     subroutine ssyr2k(uplo,trans,n,k,alpha,a,lda,b,ldb,beta,c,ldc)
           character*1        uplo, trans
           integer            n, k, lda, ldb, ldc
           real               alpha, beta
           real               a( lda,*), b( ldb,*), c(ldc,*)

     subroutine zsyr2k(uplo,trans,n,k,alpha,a,lda,b,ldb,beta,c,ldc)
           character*1        uplo, trans
           integer            n, k, lda, ldb, ldc
           double complex     alpha, beta
           double complex     a( lda,*), b( ldb,*), c(ldc,*)

     subroutine csyr2k(uplo,trans,n,k,alpha,a,lda,b,ldb,beta,c,ldc)
           character*1        uplo, trans
           integer            n, k, lda, ldb, ldc
           complex            alpha, beta
           complex            a( lda,*), b( ldb,*), c(ldc,*)



C SYNOPSIS
     void dsyr2k(uplo,trans,n,k,alpha,a,lda,b,ldb,beta,c,ldc)
           MatrixTriangle     uplo;
           MatrixTranspose    trans;
           Integer            n, k, lda, ldb, ldc;
           double             alpha, beta;
           double             (*a)[lda*k], (*b)[lda*k], (*c)[lda*n];

     void ssyr2k(uplo,trans,n,k,alpha,a,lda,b,ldb,beta,c,ldc)
           MatrixTriangle     uplo;
           MatrixTranspose    trans;
           Integer            n, k, lda, ldb, ldc;
           float              alpha, beta;
           float              (*a)[lda*k], (*b)[lda*k], (*c)[lda*n];

     void zsyr2k(uplo,trans,n,k,alpha,a,lda,b,ldb,beta,c,ldc)
           MatrixTriangle     uplo;
           MatrixTranspose    trans;
           Integer            n, k, lda, ldb, ldc;
           Zomplex            alpha, beta;
           Zomplex            (*a)[lda*k], (*b)[lda*k], (*c)[lda*n];

     void csyr2k(uplo,trans,n,k,alpha,a,lda,b,ldb,beta,c,ldc)
           MatrixTriangle     uplo;
           MatrixTranspose    trans;
           Integer            n, k, lda, ldb, ldc;
           Complex            alpha, beta;
           Complex            (*a)[lda*k], (*b)[lda*k], (*c)[lda*n];



DESCRIPTION
     dsyr2k , ssyr2k , zsyr2k and csyr2k perform one of the matrix-matrix
     operations

           C := alpha*A*B' + alpha*B*A' + beta*C,

     or

           C := alpha*A'*B + alpha*B'*A + beta*C,

     where alpha and beta are scalars, C is an n by n symmetric matrix and A
     and B are n by k matrices in the first case and k by n matrices in the
     second case.


PARAMETERS
     uplo    On entry, uplo specifies whether the matrix is an upper or lower
             triangular matrix as follows:

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

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

             Unchanged on exit.

     trans   On entry, trans specifies the operation to be performed as
             follows:

             FORTRAN
             trans = 'N' or 'n'       C := alpha*A*B' + alpha*B*A' + beta*C.
             trans = 'T' or 't'       C := alpha*A'*B + alpha*B'*A + beta*C.

             C
             trans = NoTranspose      C := alpha*A*B' + alpha*B*A' + beta*C.
             trans = Transpose        C := alpha*A'*B + alpha*B'*A + beta*C.

             Unchanged on exit.

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

     k       On entry with, trans = 'N' or 'n' or NoTranspose k specifies the
             number of columns of the matrices A and B, and on entry with
             trans = 'T' or 't' or Transpose, k specifies  the number of rows
             of the matries A and B.  K must be at least zero.
             Unchanged on exit.

     alpha   specifies the scalar alpha.
             Unchanged on exit.

     a       An array containing the matrix A.

             FORTRAN
             Array of dimension (lda, ka).

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

             ka is k when transa = 'N' or 'n' or NoTranspose and is n
             otherwise.  Before entry with trans = 'N' or 'n' or NoTranspose,
             the leading n by k part of the array a must contain the matrix A,
             otherwise the leading  k by n part of the array a must contain
             the matrix A.

             Unchanged on exit.

     lda     On entry, lda specifies the first dimension of a as declared in
             the calling (sub) program. When  transa = 'N' or 'n' or
             NoTranspose, then lda must be at least max( 1, n ), otherwise lda
             must be at least  max( 1, k ).
             Unchanged on exit.

     b       An array containing the matrix B.

             FORTRAN
             Array of dimension (lda, kb).

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

             kb is k when transa = 'N' or 'n' or NoTranspose and is n
             otherwise.  Before entry with trans = 'N' or 'n' or NoTranspose,
             the leading n by k part of the array b must contain the matrix B,
             otherwise the leading  k by n part of the array b must contain
             the matrix B.

             Unchanged on exit.

     ldb     On entry, ldb specifies the first dimension of b as declared in
             the calling (sub) program. When  trans = 'N' or 'n' or
             NoTranspose, then ldb must be at least max( 1, n ), otherwise lda
             must be at least  max( 1, k ).
             Unchanged on exit.

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

     c       An array containing the matrix C.

             FORTRAN
             An array of dimension ( ldc, n ).

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

             Before entry  with uplo = 'U' or 'u' or UpperTraingle, the
             leading  n by n triangular part  of the  symmetric matrix  and
             the strictly lower triangular part of C is not referenced.  On
             exit, the upper triangular part of the array  C is overwritten by
             the upper triangular part of the updated matrix.

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

     ldc     On entry, ldc specifies the first dimension of c as declared in
             the calling (sub) program. ldc must be at least max( 1, n ).

             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.