sger(3S)

SGER, DGER, CGERC, ZGERC, CGERU, ZGERU - Performs rank 1 update of a real or complex general matrix

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

NAME
     SGER, DGER, CGERC, ZGERC, CGERU, ZGERU - Performs rank 1 update of a real
     or complex general matrix

SYNOPSIS
     Single precision

          Fortran:
               CALL SGER (m, n, alpha, x, incx, y, incy, a, lda)

          C/C++:
               #include <scsl_blas.h>
               void sger (int m, int n, float alpha, float *x, int x, float
               *y, int y, float *a, int lda);

     Double precision

          Fortran:
               CALL DGER (m, n, alpha, x, incx, y, incy, a, lda)

          C/C++:
               #include <scsl_blas.h>
               void dger (int m, int n, double alpha, double *x, int x, double
               *y, int y, double *a, int lda);

     Single precision complex

          Fortran:
               CALL CGERC (m, n, alpha, x, incx, y, incy, a, lda)

               CALL CGERU (m, n, alpha, x, incx, y, incy, a, lda)

          C/C++:
               #include <scsl_blas.h>

               void cgerc (int m, int n, scsl_complex *alpha, scsl_complex *x,
               int incx, scsl_complex *y, int incy, scsl_complex *a, int lda);

               void cgeru (int m, int n, scsl_complex *alpha, scsl_complex *x,
               int incx, scsl_complex *y, int incy, scsl_complex *a, int lda);

          C++ STL:
               #include <complex.h>
               #include <scsl_blas.h>

               void cgerc (int m, int n, complex<float> *alpha, complex<float>
               *x, int incx, complex<float> *y, int incy, complex<float> *a,
               int lda);

               void cgeru (int m, int n, complex<float> *alpha, complex<float>
               *x, int incx, complex<float> *y, int incy, complex<float> *a,
               int lda);
     Double precision complex

          Fortran:
               CALL ZGERC (m, n, alpha, x, incx, y, incy, a, lda)

               CALL ZGERU (m, n, alpha, x, incx, y, incy, a, lda)

          C/C++:
               #include <scsl_blas.h>

               void zgerc (int m, int n, scsl_zomplex *alpha, scsl_zomplex *x,
               int x, scsl_zomplex *y, int y, scsl_zomplex *a, int lda);

               void zgeru (int m, int n, scsl_zomplex *alpha, scsl_zomplex *x,
               int x, scsl_zomplex *y, int y, scsl_zomplex *a, int lda);

          C++ STL:
               #include <complex.h>
               #include <scsl_blas.h>

               void zgerc (int m, int n, complex<double> *alpha,
               complex<double> *x, int x, complex<double> *y, int y,
               complex<double> *a, int lda);

               void zgeru (int m, int n, complex<double> *alpha,
               complex<double> *x, int x, complex<double> *y, int y,
               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
     SGER and DGER perform a rank 1 update of a real general matrix.

     CGERC and ZGERC perform a conjugated rank 1 update of a complex general
     matrix.

     CGERU and ZGERU perform an unconjugated rank 1 update of a complex
     general matrix.

     SGER, DGER, CGERU, and ZGERU perform the rank 1 operation:

          A <- alpha xyT + A

     where yT is the transpose of y, alpha is a scalar, x is an m-element
     vector, y is an n-element vector, and A is an m-by-n matrix.

     CGERC and ZGERC perform the rank 1 operation:

          A <- alpha xyH + A

     where yH is the conjugate transpose of y, alpha is a scalar, x is an
     m-element vector, y is an n-element vector, and A is an m-by-n 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:

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

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

     alpha     Scalar alpha.  (input)
               SGER: Single precision.
               DGER: Double precision.
               CGERC, CGERU: Single precision complex.
               ZGERC, ZGERU: 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+(m-1) * |incx|.  (input)
               SGER: Single precision array.
               DGER: Double precision array.
               CGERC, CGERU: Single precision complex array.
               ZGERC, ZGERU: Double precision complex array.
               Contains vector x.

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

     y         Array of dimension 1+(n-1) * |incy|.  (input)
               SGER: Single precision array.
               DGER: Double precision array.
               CGERC, CGERU: Single precision complex array.
               ZGERC, ZGERU: Double precision complex array.
               Contains vector y.

     incy      Integer.  (input)
               Specifies the increment for the elements of y.  incy must not
               be 0.

     a         Array of dimension (lda,n).  (input and output)
               SGER: Single precision array.
               DGER: Double precision array.
               CGERC, CGERU: Single precision complex array.
               ZGERC, ZGERU: Double precision complex array.
               Before entry, the leading m-by-n part of array a must contain
               the matrix of coefficients.  On exit, the updated matrix
               overwrites array a.

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

NOTES
     SGER, DGER, CGERC, ZGERC, CGERU, and ZGERU  are Level 2 Basic Linear
     Algebra Subprograms (Level 2 BLAS).

     When working backward (incx < 0 or incy < 0), these routines start at the
     end of the vector and move backward, as follows:

          x(1-incx * (n-1)), x(1-incx * (n-2)) , ..., x(1)

          y(1-incy * (n-1)), y(1-incy * (n-2)) , ..., y(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)

     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.