her2k(3F)

NAME
     zher2k, cher2k - BLAS level three   Hermitian Rank 2K Update


FORTRAN 77 SYNOPSIS
     subroutine zher2k( 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 cher2k( 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
     subroutine zher2k( 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 zher2k( 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
     zher2k and cher2k perform one of the hermitian rank 2k operations

           C := alpha*A*conjg( B' ) + conjg( alpha )*B*conjg( A' ) + beta*C,

     or

           C := alpha*conjg( A' )*B + conjg( alpha )*conjg( B' )*A + beta*C,

     where alpha and beta are scalars with beta real, C is an n by n hermitian
     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*conjg( B' )          +
                                                conjg( alpha )*B*conjg( A' ) +
                                                beta*C.
             trans = 'C' or 'c'            C := alpha*conjg( A' )*B          +
                                                conjg( alpha )*conjg( B' )*A +
                                                beta*C.

             C
             trans = NoTranspose           C := alpha*A*conjg( B' )          +
                                                conjg( alpha )*B*conjg( A' ) +
                                                beta*C.
             trans = ConjugateTranspose    C := alpha*conjg( A' )*B          +
                                                conjg( alpha )*conjg( 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.

       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.