ssymv, dsymv, chemv, zhemv 

Matrix-vector product for a symmetric or hermitian matrix

FORMAT

  {S,D}SYMV (uplo, n, alpha, a, lda, x, incx, beta, y, incy) {C,Z}HEMV (uplo,
  n, alpha, a, lda, x, incx, beta, y, incy)

Arguments

  uplo                character*1
                      On entry, specifies whether the upper- or lower-
                      triangular part of the array A is referenced:

                      If uplo = 'U' or 'u', the upper-triangular part of A is
                      referenced.

                      If uplo = 'L' or 'l', the lower-triangular part of A is
                      referenced.
                      On exit, uplo is unchanged.

  n                   integer*4
                      On entry, the order of the matrix A; n >= 0.
                      On exit, n is unchanged.

  alpha               real*4 | real*8 | complex*8 | complex*16
                      On entry, the scalar alpha*.
                      On exit, alpha is unchanged.

  a                   real*4 | real*8 | complex*8 | complex*16
                      On entry, a two-dimensional array with dimensions lda
                      by n.

  When uplo specifies the upper portion of the matrix, the leading n by n
  part of the array contains the upper-triangular part of the matrix, and the
  lower-triangular part of array A is not referenced.

  When uplo specifies the lower  portion of the matrix,  the leading n by n
  part of the array contains the lower-triangular part of the matrix, and the
  upper-triangular part of array A is not referenced.

  For CHEMV and ZHEMV routines,  the imaginary parts of the diagonal elements
  are not accessed, need not be  set, and are assumed to be zero.
  On exit, a is unchanged.

  lda                 integer*4
                      On entry, the first dimension of array A; lda >=
                      MAX(1,n).
                      On exit, lda is unchanged.

  x                   real*4 | real*8 | complex*8 | complex*16
                      On entry, a one-dimensional array X of length at least
                      (1+(n-1)*|incx|).  Array X contains the vector x.
                      On exit, x is unchanged.

  incx                integer*4
                      On entry, the increment for the elements of X; incx
                      must not equal zero.
                      On exit, incx is unchanged.

  beta                real*4 | real*8 | complex*8 | complex*16
                      On entry, the scalar beta.
                      On exit, beta is unchanged.

  y                   real*4 | real*8 | complex*8 | complex*16
                      On entry, a one-dimensional array Y of length at least
                      (1+(n-1)*|incy|).

  If beta= 0, y need not be set.  If betais not equal to zero, the
  incremented array Y must contain the vector y.
  On exit, y is overwritten by the updated vector y.

  incy                integer*4
                      On entry, the increment for the elements of Y; incy
                      must not equal zero.
                      On exit, incy is unchanged.

Description

  SSYMV and DSYMV compute a matrix-vector product for a real symmetric
  matrix.  CHEMV and ZHEMV compute a matrix-vector product for a complex
  Hermitian matrix.  Both products are described by the following operation:
  y  = alpha*Ax + beta*y

  alpha and beta are scalars, x and y are vectors with n elements, and A is
  an n by n matrix. In the case of SSYMV and DSYMV, matrix A is a symmetric
  matrix and in the case of CHEMV and ZHEMV, matrix A is a Hermitian matrix.

EXAMPLES

  REAL*8 A(100,40), X(40), Y(40), alpha, beta
  N = 40
  INCX = 1
  INCY = 1
  alpha = 1.0D0
  beta = 0.0D0
  LDA = 100
  CALL DSYMV('U',N,alpha,A,LDA,X,INCX,beta,Y,INCY)

  This FORTRAN code computes the product y  =  Ax where A is a symmetric
  matrix, of order 40, with its upper-triangular part stored.

  COMPLEX*8 A(100,40), X(40), Y(40), alpha, beta
  N = 40
  INCX = 1
  INCY = 1
  alpha = (1.0, 0.5)
  beta = (0.0, 0.0)
  LDA = 100
  CALL CHEMV('U',N,alpha,A,LDA,X,INCX,beta,Y,INCY)

  This FORTRAN code computes the product y  =  Ax where A is a Hermitian
  matrix, of order 40, with its upper-triangular part stored.