SAXPBY(3S)SAXPBY(3S)NAME
SAXPBY, DAXPBY, CAXPBY, ZAXPBY - Adds a scalar multiple of a Single
precision or complex vector x to a scalar multiple of another Single
precision or complex vector y
SYNOPSIS
Single precision
Fortran:
CALL SAXPBY (n, alpha, x, incx, beta, y, incy)
C/C++:
#include <scsl_blas.h>
void saxpby( int n, float alpha, float *x, int incx, float
beta, float *y, int incy );
Double precision
Fortran:
CALL DAXPBY (n, alpha, x, incx, beta, y, incy)
C/C++:
#include <scsl_blas.h>
void daxpby( int n, double alpha, double *x, int incx, double
beta, double *y, int incy );
Single precision complex
Fortran:
CALL CAXPBY (n, alpha, x, incx, beta, y, incy)
C/C++:
#include <scsl_blas.h>
void caxpby( int n, scsl_complex *alpha, scsl_complex *x, int
incx, scsl_complex *beta, scsl_complex *y, int incy );
C++ STL:
#include <complex.h>
#include <scsl_blas.h>
void caxpby( int n, complex<float> *alpha, complex<float>
*x,int incx, complex<float> *beta, complex<float> *y, int incy
);
Double precision complex
Fortran:
CALL ZAXPBY (n, alpha, x, incx, beta, y, incy)
C/C++:
#include <scsl_blas.h>
void zaxpby( int n, scsl_zomplex *alpha, scsl_zomplex *x, int
incx, scsl_zomplex *beta, scsl_zomplex *y, int incy );
Page 1
SAXPBY(3S)SAXPBY(3S)
C++ STL:
#include <complex.h>
#include <scsl_blas.h>
void zaxpby( int n, complex<double> *alpha, complex<double> *x,
int incx, complex<double> *beta, complex<double> *y, int incy
);
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
SAXPBY/DAXPBY adds a scalar multiple of a real vector x to a scalar
multiple of a real vector y.
CAXPBY/ZAXPBY adds a scalar multiple of a complex vector x to a scalar
multiple of a complex vector y:
y <- alpha x + beta y
where x and y are n-vectors and alpha and beta are scalars.
The following special cases are recognized:
* alpha = 0: equivalent to SSCAL, DSCAL, CSCAL, ZSCAL
* alpha = 1, beta = 0: equivalent to SCOPY, CCOPY, DCOPY, ZCOPY
* alpha not equal to 1, beta = 0: like SCOPY, CCOPY, DCOPY, ZCOPY with
scaling
* alpha not equal to 0, beta = 1: equivalent to SAXPY, CAXPY, DAXPY,
ZAXPY
See the NOTES section of this man page for information about the
interpretation of the data types described in the following arguments.
Page 2
SAXPBY(3S)SAXPBY(3S)
These routines have the following arguments:
n Integer. (input)
Number of elements of the vectors x and y.
alpha Scalar alpha (input).
SAXPBY: Single precision.
DAXPBY: Double precision.
CAXPBY: Single precision complex.
ZAXPBY: 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)
SAXPBY: Single precision array.
DAXPBY: Double precision array.
CAXPBY: Single precision omplex array.
ZAXPBY: Double precision complex array.
The vector x. If incx > 0, the i-th element of the vector x is
located in x(1+(i-1) * |incx|). If incx < 0, the i-th element
of the vector x is located in x(1+(n-i) * |incx|).
incx Integer. (input)
Increment between elements of the vector x. If incx < 0, x is
processed in reverse order.
beta Scalar beta. (input)
SAXPBY: Single precision scalar.
DAXPBY: Double precision scalar.
CAXPBY: Single precision complex scalar.
ZAXPBY: Double precision complex scalar.
For C/C++, a pointer to this scalar is passed when beta is
complex; otherwise, beta is passed by value.
y Array of dimension (1+(n-1) * |incy|). (input/output)
SAXPBY: Single precision array.
DAXPBY: Double precision array.
CAXPBY: Single precision complex array.
ZAXPBY: Double complex array.
On entry, the vector y. If incy > 0, the i-th element of the
vector y is located in y(1+(i-1) * |incy|). If incy < 0, the
i-th element of the vector y is located in y(1+(n-i) * |incy|).
On exit, y is overwritten with the vector sum alphax+ betay.
incy Integer. (input)
Increment between elements of y. If incy < 0, y is processed
in reverse order.
Page 3
SAXPBY(3S)SAXPBY(3S)NOTES
These routines are extensions to the Level 1 Basic Linear Algebra
Subprograms (Level 1 BLAS).
Data Types
The following data types are described in this documentation:
Term Used Data type
Fortran:
Array dimensioned n x(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]
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]
Character char
Integer int (long long for -lscs_i8[_mp])
Page 4
SAXPBY(3S)SAXPBY(3S)
Single precision float
Double precision double
Single precision complex complex<float>
Double precision complex complex<double>
SEE ALSOINTRO_SCSL(3S), INTRO_BLAS1(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 5