SGER(3S)SGER(3S)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);
Page 1
SGER(3S)SGER(3S)
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.
Page 2
SGER(3S)SGER(3S)
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.
Page 3
SGER(3S)SGER(3S)
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
Page 4
SGER(3S)SGER(3S)
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 ALSOINTRO_SCSL(3S), INTRO_BLAS2(3S)
Page 5
SGER(3S)SGER(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.
Page 6