Contents


NAME

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

SYNOPSIS

     SUBROUTINE CHPR2(UPLO, N, ALPHA, X, INCX, Y, INCY, AP)

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

     SUBROUTINE CHPR2_64(UPLO, N, ALPHA, X, INCX, Y, INCY, AP)

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

  F95 INTERFACE
     SUBROUTINE HPR2(UPLO, [N], ALPHA, X, [INCX], Y, [INCY], AP)

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

     SUBROUTINE HPR2_64(UPLO, [N], ALPHA, X, [INCX], Y, [INCY], AP)

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

  C INTERFACE
     #include <sunperf.h>

     void chpr2(char uplo, int n, complex *alpha, complex *x, int
               incx, complex *y, int incy, complex *ap);

     void chpr2_64(char uplo, long n, complex *alpha, complex *x,
               long incx, complex *y, long incy, complex *ap);

PURPOSE

     chpr2  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, supplied in packed form.

ARGUMENTS

     UPLO (input)
               On entry, UPLO  specifies  whether  the  upper  or
               lower  triangular part of the matrix A is supplied
               in the packed array AP as follows:

               UPLO = 'U' or 'u'   The upper triangular part of A
               is supplied in AP.

               UPLO = 'L' or 'l'   The lower triangular part of A
               is supplied in AP.

               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.
     AP (input/output)
               ( ( n*( n + 1 ) )/2 ).  Before entry with  UPLO  =
               'U'  or  'u',  the array AP must contain the upper
               triangular part of  the  hermitian  matrix  packed
               sequentially,  column  by  column, so that AP( 1 )
               contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a(
               1,  2  ) and a( 2, 2 ) respectively, and so on. On
               exit, the array AP is  overwritten  by  the  upper
               triangular  part  of  the  updated matrix.  Before
               entry with UPLO = 'L' or 'l', the  array  AP  must
               contain the lower triangular part of the hermitian
               matrix packed sequentially, column by  column,  so
               that AP( 1 ) contains a( 1, 1 ), AP( 2 ) and AP( 3
               ) contain a( 2, 1 ) and a( 3,  1  )  respectively,
               and so on. On exit, the array AP is overwritten by
               the lower triangular part of the  updated  matrix.
               Note that the imaginary parts of the diagonal ele-
               ments need not be set,  they  are  assumed  to  be
               zero, and on exit they are set to zero.