Contents


NAME

     cher2 - perform  the  hermitian  rank  2  operation    A  :=
     alpha*x*conjg( y' ) + conjg( alpha )*y*conjg( x' ) + A

SYNOPSIS

     SUBROUTINE CHER2(UPLO, N, ALPHA, X, INCX, Y, INCY, A, LDA)

     CHARACTER * 1 UPLO
     COMPLEX ALPHA
     COMPLEX X(*), Y(*), A(LDA,*)
     INTEGER N, INCX, INCY, LDA

     SUBROUTINE CHER2_64(UPLO, N, ALPHA, X, INCX, Y, INCY, A, LDA)

     CHARACTER * 1 UPLO
     COMPLEX ALPHA
     COMPLEX X(*), Y(*), A(LDA,*)
     INTEGER*8 N, INCX, INCY, LDA

  F95 INTERFACE
     SUBROUTINE HER2(UPLO, [N], ALPHA, X, [INCX], Y, [INCY], A, [LDA])

     CHARACTER(LEN=1) :: UPLO
     COMPLEX :: ALPHA
     COMPLEX, DIMENSION(:) :: X, Y
     COMPLEX, DIMENSION(:,:) :: A
     INTEGER :: N, INCX, INCY, LDA

     SUBROUTINE HER2_64(UPLO, [N], ALPHA, X, [INCX], Y, [INCY], A, [LDA])

     CHARACTER(LEN=1) :: UPLO
     COMPLEX :: ALPHA
     COMPLEX, DIMENSION(:) :: X, Y
     COMPLEX, DIMENSION(:,:) :: A
     INTEGER(8) :: N, INCX, INCY, LDA

  C INTERFACE
     #include <sunperf.h>

     void cher2(char uplo, int n, complex *alpha, complex *x, int
               incx, complex *y, int incy, complex *a, int lda);

     void cher2_64(char uplo, long n, complex *alpha, complex *x,
               long incx, complex *y, long incy, complex *a, long
               lda);

PURPOSE

     cher2  performs  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 hermitian matrix.

ARGUMENTS

     UPLO (input)
               On entry, UPLO  specifies  whether  the  upper  or
               lower  triangular  part  of  the  array A is to be
               referenced as follows:

               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.

               Unchanged on exit.

     N (input)
               On entry, N specifies the order of the  matrix  A.
               N >= 0.  Unchanged on exit.

     ALPHA (input)
               On  entry,  ALPHA  specifies  the  scalar   alpha.
               Unchanged on exit.

     X (input)
               ( 1 + ( n - 1 )*abs( INCX ) ).  Before entry,  the
               incremented  array  X  must  contain the n element
               vector x.  Unchanged on exit.

     INCX (input)
               On entry, INCX specifies  the  increment  for  the
               elements of X. INCX <> 0.  Unchanged on exit.

     Y (input)
               ( 1 + ( n - 1 )*abs( INCY ) ).  Before entry,  the
               incremented  array  Y  must  contain the n element
               vector y.  Unchanged on exit.

     INCY (input)
               On entry, INCY specifies  the  increment  for  the
               elements of Y. INCY <> 0.  Unchanged on exit.

     A (input/output)
               Before entry with  UPLO = 'U' or 'u', the  leading
               n  by  n upper triangular part of the array A must
               contain the upper triangular part of the hermitian
               matrix and the strictly lower triangular part of A
               is not referenced. On exit, the  upper  triangular
               part  of  the  array A 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 A must  contain
               the  lower triangular part of the hermitian matrix
               and the strictly upper triangular part of A is not
               referenced.  On exit, the lower triangular part of
               the array A is overwritten by the lower triangular
               part  of  the  updated matrix.  Note that the ima-
               ginary parts of the diagonal elements need not  be
               set, they are assumed to be zero, and on exit they
               are set to zero.

     LDA (input)
               On entry, LDA specifies the first dimension  of  A
               as  declared  in the calling (sub) program. LDA >=
               max( 1, n ).  Unchanged on exit.