ssyr(3S)

NAME
     SSYR, DSYR, CSYR, ZSYR - Performs symmetric rank 1 update of a real or
     complex symmetric matrix

SYNOPSIS
     Single precision

          Fortran:
               CALL SSYR (uplo, n, alpha, x, incx, a, lda)

          C/C++:
               #include <scsl_blas.h>
               void ssyr (char *uplo, int n, float alpha, float *x, int incx,
               float *a, int lda);

     Double precision

          Fortran:
               CALL DSYR (uplo, n, alpha, x, incx, a, lda)

          C/C++:
               #include <scsl_blas.h>
               void dsyr (char *uplo, int n, double alpha, double *x, int
               incx, double *a, int lda);

     Single precision complex

          Fortran:
               CALL CSYR (uplo, n, alpha, x, incx, a, lda)

          C/C++:
               #include <scsl_blas.h>
               void csyr (char *uplo, int n, scsl_complex *alpha, scsl_complex
               *x, int incx, scsl_complex *a, int lda);

          C++ STL:
               #include <complex.h>
               #include <scsl_blas.h>
               void csyr (char *uplo, int n, complex<float> *alpha,
               complex<float> *x, int incx, complex<float> *a, int lda);

     Double precision complex

          Fortran:
               CALL ZSYR (uplo, n, alpha, x, incx, a, lda)

          C/C++:
               #include <scsl_blas.h>
               void zsyr (char *uplo, int n, scsl_zomplex *alpha, scsl_zomplex
               *x, int incx, scsl_zomplex *a, int lda);
          C++ STL:
               #include <complex.h>
               #include <scsl_blas.h>
               void zsyr (char *uplo, int n, complex<double> *alpha,
               complex<double> *x, int incx, complex<double> *a, int lda);

IMPLEMENTATION
     These routines are part of the SCSL Scientific Library and can be loaded
     using either the -lscs or the -lscs_mp option.  The -lscs_mp option
     directs the linker to use the multi-processor version of the library.

     When linking to SCSL with -lscs or -lscs_mp, the default integer size is
     4 bytes (32 bits). Another version of SCSL is available in which integers
     are 8 bytes (64 bits).  This version allows the user access to larger
     memory sizes and helps when porting legacy Cray codes.  It can be loaded
     by using the -lscs_i8 option or the -lscs_i8_mp option. A program may use
     only one of the two versions; 4-byte integer and 8-byte integer library
     calls cannot be mixed.

     The C and C++ prototypes shown above are appropriate for the 4-byte
     integer version of SCSL. When using the 8-byte integer version, the
     variables of type int become long long and the <scsl_blas_i8.h> header
     file should be included.

DESCRIPTION
     These routines perform the following symmetric rank 1 operation:

          A <- alpha xxT + A

     where xT is the transpose of x, alpha is a real or complex scalar, x is
     an n-element vector, and A is an n-by-n symmetric matrix.

     See the NOTES section of this man page for information about the
     interpretation of the data types described in the following arguments.

     These routines have the following arguments:

     uplo      Character.  (input)
               Specifies whether the upper or lower triangular part of array a
               is referenced, as follows:

               uplo= 'U' or 'u':  only the upper triangular part of a is
               referenced.
               uplo= 'L' or 'l':  only the lower triangular part of a is
               referenced.

               For C/C++, a pointer to this character is passed.

     n         Integer.  (input)
               Specifies the order of matrix A.  n >= 0.
     alpha     Scalar alpha.  (input)
               SSYR: Single precision.
               DSYR: Double precision.
               CSYR: Single precision complex.
               ZSYR: Double precision complex.

               For C/C++, a pointer to this scalar is passed when alpha is
               complex; otherwise, alpha is passed by value.

     x         Array of dimension 1+(n-1) * |incx|.  (input)
               SSYR: Single precision array.
               DSYR: Double precision array.
               CSYR: Single precision complex array.
               ZSYR: Double precision complex array.
               Contains vector x.

     incx      Integer.  (input)
               Specifies the increment for the elements of x.  incx must not
               be 0.

     a         Array of dimension (lda,n).  (input and output)
               SSYR: Single precision array.
               DSYR: Double precision array.
               CSYR: Single precision complex array.
               ZSYR: Double precision complex array.

               Before entry with uplo = 'U' or 'u', the leading n-by-n upper
               triangular part of array a must contain the upper triangular
               part of the symmetric matrix.  The strictly lower triangular
               part of a is not referenced.  On exit, the upper triangular
               part of the updated matrix overwrites the upper triangular part
               of array a.

               Before entry with uplo = 'L' or 'l', the leading n-by-n lower
               triangular part of array a must contain the lower triangular
               part of the symmetric matrix.  The strictly upper triangular
               part of a is not referenced.  On exit, the lower triangular
               part of the updated matrix overwrites the lower triangular part
               of array a.

     lda       Integer.  (input)
               Specifies the first dimension of a as declared in the calling
               program.  lda >= MAX(1,n).

NOTES
     SSYR/DSYR is a Level 2 Basic Linear Algebra Subprogram (Level 2 BLAS).
     CSYR/ZSYR is an extension to Level 2 BLAS.

     When working backward (incx < 0), each routine starts at the end of the
     vector and moves backward, as follows:
          x(1-incx * (n-1)), x(1-incx * (n-2)), ..., x(1)


   Data Types
     The following data types are described in this documentation:

          Term Used                     Data type

     Fortran:

          Array dimensioned n           x(n)

          Array of dimensions (m,n)     x(m,n)

          Character                     CHARACTER

          Integer                       INTEGER (INTEGER*8 for -lscs_i8[_mp])

          Single precision              REAL

          Double precision              DOUBLE PRECISION

          Single precision complex      COMPLEX

          Double precision complex      DOUBLE COMPLEX

     C/C++:

          Array dimensioned n           x[n]

          Array of dimensions (m,n)     x[m*n]

          Character                     char

          Integer                       int (long long for -lscs_i8[_mp])

          Single precision              float

          Double precision              double

          Single precision complex      scsl_complex

          Double precision complex      scsl_zomplex

     C++ STL:

          Array dimensioned n           x[n]

          Array of dimensions (m,n)     x[m*n]

          Character                     char

          Integer                       int (long long for -lscs_i8[_mp])

          Single precision              float

          Double precision              double

          Single precision complex      complex<float>

          Double precision complex      complex<double>

     Note that you can explicitly declare multidimensional C/C++ arrays
     provided that the array dimensions are swapped with respect to the
     Fortran declaration (e.g., x[n][m] in C/C++ versus x(m,n) in Fortran).
     To avoid a compiler type mismatch error in C++ (or a compiler warning
     message in C), however, the array should be cast to a pointer of the
     appropriate type when passed as an argument to a SCSL routine.

SEE ALSO
     INTRO_SCSL(3S), INTRO_BLAS2(3S), CHER(3S)

     INTRO_CBLAS(3S) for information about using the C interface to Fortran 77
     Basic Linear Algebra Subprograms (legacy BLAS) set forth by the Basic
     Linear Algebra Subprograms Technical Forum.