ssymm(3S)

SSYMM, DSYMM, CSYMM, ZSYMM - Multiplies a real or complex general matrix by a real or complex symmetric matrix

Showing IRIX 6.5.30 (default release). Added in IRIX 6.5.15.

NAME
     SSYMM, DSYMM, CSYMM, ZSYMM - Multiplies a real or complex general matrix
     by a real or complex symmetric matrix

SYNOPSIS
     Single precision

          Fortran:
               CALL SSYMM (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c,
               ldc)

          C/C++:
               #include <scsl_blas.h>
               void ssymm (char *side, char *uplo, int m, int n, float alpha,
               float *a, int lda, float *b, int ldb, float beta, float *c, int
               ldc);

     Double precision

          Fortran:
               CALL DSYMM (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c,
               ldc)

          C/C++:
               #include <scsl_blas.h>
               void dsymm (char *side, char *uplo, int m, int n, double alpha,
               double *a, int lda, double *b, int ldb, double beta, double *c,
               int ldc);

     Single precision complex

          Fortran:
               CALL CSYMM (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c,
               ldc)

          C/C++:
               #include <scsl_blas.h>
               void csymm (char *side, char *uplo, int m, int n, scsl_complex
               *alpha, scsl_complex *a, int lda, scsl_complex *b, int ldb,
               scsl_complex *beta, scsl_complex *c, int ldc);

          C++ STL:
               #include <complex.h>
               #include <scsl_blas.h>
               void csymm (char *side, char *uplo, int m, int n,
               complex<float> *alpha, complex<float> *a, int lda,
               complex<float> *b, int ldb, complex<float> *beta,
               complex<float> *c, int ldc);

     Double precision complex
          Fortran:
               CALL ZSYMM (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c,
               ldc)

          C/C++:
               #include <scsl_blas.h>
               void zsymm (char *side, char *uplo, int m, int n, scsl_zomplex
               *alpha, scsl_zomplex *a, int lda, scsl_zomplex *b, int ldb,
               scsl_zomplex *beta, scsl_zomplex *c, int ldc);

          C++ STL:
               #include <complex.h>
               #include <scsl_blas.h>
               void zsymm (char *side, char *uplo, int m, int n,
               complex<double> *alpha, complex<double> *a, int lda,
               complex<double> *b, int ldb, complex<double> *beta,
               complex<double> *c, int ldc);

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
     SSYMM and DSYMM multiply a real general matrix by a real symmetric
     matrix.

     CSYMM and ZSYMM multiply a complex general matrix by a complex symmetric
     matrix.

     These routines perform one of the following matrix-matrix operations:

          C <- alpha AB + beta C

          or

          C <- alpha BA + beta C
     where alpha and beta are scalars, A is a symmetric matrix, and B and C
     are m-by-n matrices.

     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:

     side      Character.  (input)
               Specifies whether the symmetric matrix A appears on the left or
               right in the operation, as follows:

               side = 'L' or 'l':  C <- alpha AB + beta C
               side = 'R' or 'r'; C <- alpha BA + beta C

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

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

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

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

     m         Integer.  (input)
               Specifies the number of rows in matrix C.  m must be >= 0.

     n         Integer.  (input)
               Specifies the number of columns in matrix C.  n must be >= 0.

     alpha     Scalar factor.  (input)
               SSYMM: Single precision.
               DSYMM: Double precision.
               CSYMM: Single precision complex.
               ZSYMM: Double precision complex.

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

     a         Array of dimension (lda,ka).  (input)
               SSYMM: Single precision array.
               DSYMM: Double precision array.
               CSYMM: Single precision complex array.
               ZSYMM: Double precision complex array.
               When side = 'L' or 'l', ka is m; otherwise, it is n.  Contains
               the matrix A.
               Before entry with side = 'L' or 'l', the m-by-m part of array a
               must contain the symmetric matrix A, such that:

               *   If uplo = 'U' or 'u', the leading m-by-m 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.

               *   If uplo = 'L' or 'l', the leading m-by-m 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.

               Before entry with side = 'R' or 'r', the n-by-n part of array a
               must contain the symmetric matrix A, such that:

               *   If 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.

               *   If 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.

     lda       Integer.  (input)
               Specifies the first dimension of a as declared in the calling
               program.  When side = 'L' or 'l', lda >= MAX(1,m); otherwise,
               lda >= MAX(1,n).

     b         Array of dimension (ldb,n).  (input)
               SSYMM: Single precision array.
               DSYMM: Double precision array.
               CSYMM: Single precision complex array.
               ZSYMM: Double precision complex array.

               Contains the matrix B.  Before entry, the leading m-by-n part
               of array b must contain matrix B.

     ldb       Integer.  (input)
               Specifies the first dimension of b as declared in the calling
               program.  ldb >= MAX(1,m).

     beta      Scalar factor.  (input)
               SSYMM: Single precision.
               DSYMM: Double precision.
               CSYMM: Single precision complex.
               ZSYMM: Double precision complex.  When beta is supplied as 0, c
               need not be set on input.
               For C/C++, a pointer to this scalar is passed when beta is
               complex; otherwise, beta is passed by value.

     c         Array of dimension (ldc,n).  (input and output)
               SSYMM: Single precision array.
               DSYMM: Double precision array.
               CSYMM: Single precision complex array.
               ZSYMM: Double precision complex array.

               Contains the matrix C.  Before entry, the leading m-by-n part
               of array c must contain matrix C, except when beta is 0; in
               which case, c need not be set.  On exit, the m-by-n updated
               matrix overwrites array c.

     ldc       Integer.  (input)
               Specifies the first dimension of c as declared in the calling
               program.  ldc >= MAX(1,m).

NOTES
     These routines are Level 3 Basic Linear Algebra Subprograms (Level 3
     BLAS).


   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                     *Cchar

          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_BLAS3(3S) CHEMM(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.