Contents

• NAME
• SYNOPSIS
  • F95 INTERFACE
  • C INTERFACE
• PURPOSE
• ARGUMENTS

NAME

     ssymv - perform the matrix-vector operation   y := alpha*A*x
     + beta*y

SYNOPSIS

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

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

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

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

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

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

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

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

  C INTERFACE
     #include <sunperf.h>

     void ssymv(char uplo, int n, float alpha, float *a, int lda,
               float  *x,  int  incx,  float  beta, float *y, int
               incy);

     void ssymv_64(char uplo, long n, float alpha, float *a, long
               lda,  float  *x,  long incx, float beta, float *y,
               long incy);

PURPOSE

     ssymv performs the matrix-vector  operation y := alpha*A*x +
     beta*y, where alpha and beta are scalars, x and y are n ele-
     ment vectors and A is an n by n symmetric 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.

     A (input)
               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 symmetric
               matrix and the strictly lower triangular part of A
               is not referenced.  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  symmetric  matrix  and the strictly
               upper triangular part  of  A  is  not  referenced.
               Unchanged on exit.

     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.

     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.

     BETA (input)
               On entry, BETA specifies  the  scalar  beta.  When
               BETA is supplied as zero then Y need not be set on
               input.  Unchanged on exit.

     Y (input/output)
               ( 1 + ( n - 1 )*abs( INCY ) ).  Before entry,  the
               incremented  array  Y  must  contain the n element
               vector y. On exit, Y is overwritten by the updated
               vector y.

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