void ATL_zrefhpr2
(
const enum ATLAS_UPLO UPLO,
const int N,
const double * ALPHA,
const double * X,
const int INCX,
const double * Y,
const int INCY,
double * A
)
{
/*
* Purpose
* =======
*
* ATL_zrefhpr2 performs the Hermitian rank 2 operation
*
* A := alpha * x * conjg( y' ) + y * conjg( alpha * x' ) + A,
*
* where alpha is a scalar, x and y are n-element vectors and A is an n
* by n Hermitian matrix, supplied in packed form.
*
* Arguments
* =========
*
* UPLO (input) const enum ATLAS_UPLO
* On entry, UPLO specifies whether the upper or lower triangu-
* lar part of the matrix A is supplied in the packed array A
* as follows:
*
* UPLO = AtlasUpper The upper triangular part of A is
* supplied in A.
*
* UPLO = AtlasLower The lower triangular part of A is
* supplied in A.
*
* Unchanged on exit.
*
* N (input) const int
* On entry, N specifies the order of the matrix A. N must be at
* least zero. Unchanged on exit.
*
* ALPHA (input) const double *
* On entry, ALPHA specifies the scalar alpha. When ALPHA is
* supplied as zero then the arrays X and Y need not be set on
* input. Unchanged on exit.
*
* X (input) const double *
* On entry, X points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCX ) ) * sizeof( double[2] ),
* that contains the vector x. Unchanged on exit.
*
* INCX (input) const int
* On entry, INCX specifies the increment for the elements of X.
* INCX must not be zero. Unchanged on exit.
*
* Y (input) const double *
* On entry, Y points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCY ) ) * sizeof( double[2] ),
* that contains the vector y. Unchanged on exit.
*
* INCY (input) const int
* On entry, INCY specifies the increment for the elements of Y.
* INCY must not be zero. Unchanged on exit.
*
* A (input/output) double *
* On entry, A points to an array of size equal to or greater
* than (( n*(n+1) ) / 2) * sizeof( double[2] ). Before entry
* with UPLO = AtlasUpper, the array A must contain the upper
* triangular part of the Hermitian matrix packed sequentially,
* column by column, so that A[0] contains a(0,0), A[ 1 ] and
* A[ 2 ] contain a(0,1) and a(1,1) respectively, and so on. On
* exit, the array A is overwritten by the upper triangular part
* of the updated matrix. Before entry with UPLO = AtlasLower,
* the array A must contain the lower triangular part of the
* Hermitian matrix packed sequentially, column by column, so
* that A[ 0 ] contains a(0,0), A[ 1 ] and A[ 2 ] contain a(1,0)
* and a(2,0) respectively, and so on. On exit, the array A is
* overwritten by the lower triangular part of the updated ma-
* trix.
* Note that the imaginary parts of the diagonal elements need
* not be set, they are assumed to be zero, and on exit they are
* set to zero.
*
* ---------------------------------------------------------------------
*/
/* ..
* .. Executable Statements ..
*
*/
if( ( N == 0 ) || Mdzero( ALPHA[0], ALPHA[1] ) ) return;
if( UPLO == AtlasUpper )
{
ATL_zrefhpr2U( N, ALPHA, X, INCX, Y, INCY, A, 1 );
}
else
{
ATL_zrefhpr2L( N, ALPHA, X, INCX, Y, INCY, A, N );
}
/*
* End of ATL_zrefhpr2
*/
}
void ATL_zrefgpru
(
const enum ATLAS_UPLO UPLO,
const int M,
const int N,
const double * ALPHA,
const double * X,
const int INCX,
const double * Y,
const int INCY,
double * A,
const int LDA
)
{
/*
* Purpose
* =======
*
* ATL_zrefgpru performs the rank 1 operation
*
* A := alpha * x * y' + A,
*
* where alpha is a scalar, x is an m-element vector, y is an n-element
* vector and A is an m by n packed matrix.
*
* Arguments
* =========
*
* UPLO (input) const enum ATLAS_UPLO
* On entry, UPLO specifies whether the array A contains an up-
* per or lower packed submatrix as follows:
*
* UPLO = AtlasUpper A is an upper-packed submatrix,
*
* UPLO = AtlasLower A is a lower-packed submatrix.
*
* Unchanged on exit.
*
* M (input) const int
* On entry, M specifies the number of rows of the matrix A.
* M must be at least zero. Unchanged on exit.
*
* N (input) const int
* On entry, N specifies the number of columns of the matrix A.
* N must be at least zero. Unchanged on exit.
*
* ALPHA (input) const double *
* On entry, ALPHA specifies the scalar alpha. When ALPHA is
* supplied as zero then the arrays X and Y need not be set on
* input. Unchanged on exit.
*
* X (input) const double *
* On entry, X points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( m - 1 ) * abs( INCX ) ) * sizeof( double[2] ),
* that contains the vector x. Unchanged on exit.
*
* INCX (input) const int
* On entry, INCX specifies the increment for the elements of X.
* INCX must not be zero. Unchanged on exit.
*
* Y (input) const double *
* On entry, Y points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCY ) ) * sizeof( double[2] ),
* that contains the vector y. Unchanged on exit.
*
* INCY (input) const int
* On entry, INCY specifies the increment for the elements of Y.
* INCY must not be zero. Unchanged on exit.
*
* A (input/output) double *
* On entry, A points to an array of size equal to or greater
* than ( LDA * n - sum( 1 .. n-1, k ) ) * sizeof( double[2] ).
* Before entry with UPLO = AtlasUpper, the array A must contain
* the entries of the matrix packed sequentially, column by co-
* lumn, so that A[0] contains a(0,0), A[1] and A[2] contain
* a(1,0) and a(2,0), A[LDA] and A[2*LDA+1] contain a(0,1) and
* a(0,2) respectively. Before entry with UPLO = AtlasLower, the
* array A must contain the entries of the matrix packed sequen-
* tially, column by column, so that A[0] contains a(0,0), A[1]
* and A[2] contain a(1,0) and a(2,0), A[LDA] and A[2*LDA-1]
* contain a(1,1) and a(2,2) respectively, and so on. On exit,
* A is overwritten by the updated matrix.
*
* LDA (input) const int
* On entry, LDA specifies the length of the first column of A.
* LDA must be at least MAX( 1, m ) when TRANS = AtlasNotrans
* or TRANS = AtlasConj, and MAX( 1, n ) otherwise. Unchanged on
* exit.
*
* ---------------------------------------------------------------------
*/
/* ..
* .. Executable Statements ..
*
*/
if( ( M == 0 ) || ( N == 0 ) || Mdzero( ALPHA[0], ALPHA[1] ) ) return;
if( UPLO == AtlasLower )
{ ATL_zrefgpruL( M, N, ALPHA, X, INCX, Y, INCY, A, LDA ); }
else
{ ATL_zrefgpruU( M, N, ALPHA, X, INCX, Y, INCY, A, LDA ); }
/*
* End of ATL_zrefgpru
*/
}
void ATL_zrefgbmv
(
const enum ATLAS_TRANS TRANS,
const int M,
const int N,
const int KL,
const int KU,
const double * ALPHA,
const double * A,
const int LDA,
const double * X,
const int INCX,
const double * BETA,
double * Y,
const int INCY
)
{
/*
* Purpose
* =======
*
* ATL_zrefgbmv performs one of the matrix-vector operations
*
* y := alpha * op( A ) * x + beta * y,
*
* where op( X ) is one of
*
* op( X ) = X or op( X ) = conjg( X ) or
*
* op( X ) = X' or op( X ) = conjg( X' ).
*
* where alpha and beta are scalars, x and y are vectors and op( A ) is
* an m by n band matrix, with kl sub-diagonals and ku super-diagonals.
*
* Arguments
* =========
*
* TRANS (input) const enum ATLAS_TRANS
* On entry, TRANS specifies the operation to be performed as
* follows:
*
* TRANS = AtlasNoTrans y := alpha*A *x + beta*y,
*
* TRANS = AtlasConj y := alpha*conjg( A )*x + beta*y,
*
* TRANS = AtlasTrans y := alpha*A'*x + beta*y,
*
* TRANS = AtlasConjTrans y := alpha*conjg( A' )*x + beta*y.
*
* Unchanged on exit.
*
* M (input) const int
* On entry, M specifies the number of rows of the matrix A
* when TRANS = AtlasNoTrans or TRANS = AtlasConj, and the num-
* ber of columns of the matrix A otherwise. M must be at least
* zero. Unchanged on exit.
*
* N (input) const int
* On entry, N specifies the number of columns of the matrix A
* when TRANS = AtlasNoTrans or TRANS = AtlasConj, and the num-
* ber of rows of the matrix A otherwise. N must be at least ze-
* ro. Unchanged on exit.
*
* KL (input) const int
* On entry, KL specifies the number of sub-diagonals of the ma-
* trix A. KL must satisfy 0 <= KL. Unchanged on exit.
*
* KU (input) const int
* On entry, KU specifies the number of super-diagonals of the
* matrix A. KU must satisfy 0 <= KU. Unchanged on exit.
*
* ALPHA (input) const double *
* On entry, ALPHA specifies the scalar alpha. When ALPHA is
* supplied as zero then A and X need not be set on input. Un-
* changed on exit.
*
* A (input) const double *
* On entry, A points to an array of size equal to or greater
* than LDA * ka * sizeof( double[2] ), where ka is n when
* TRANS = AtlasNotrans or TRANS = AtlasConj, and m otherwise.
* Before entry, the leading ( kl + ku + 1 ) by ka part of the
* array A must contain the matrix of coefficients, supplied
* column by column, with the leading diagonal of the matrix in
* row ku of the array, the first super-diagonal starting at po-
* sition 1 in row ku-1, the first sub-diagonal starting at po-
* sition 0 in row ku+1, and so on. Elements in the array A that
* do not correspond to elements in the band matrix (such as the
* top left ku by ku triangle) are not referenced. Unchanged on
* exit.
*
* The following program segment will transfer a real band ma-
* trix from conventional full matrix storage to band storage:
*
* for( j = 0; j < n; j++ )
* {
* k = ku - j; i1 = ( m > j + kl + 1 ? j + kl + 1 : m );
* for( i = ( k < 0 ? -k : 0 ); i < i1; i++ )
* {
* a[((k+i+j*LDA)<<1)+0] = real( matrix( i, j ) );
* a[((k+i+j*LDA)<<1)+1] = imag( matrix( i, j ) );
* }
* }
*
* LDA (input) const int
* On entry, LDA specifies the leading dimension of A as decla-
* red in the calling (sub) program. LDA must be at least
* ( kl + ku + 1 ). Unchanged on exit.
*
* X (input) const double *
* On entry, X points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCX ) ) * sizeof( double[2] ),
* that contains the vector x. Unchanged on exit.
*
* INCX (input) const int
* On entry, INCX specifies the increment for the elements of X.
* INCX must not be zero. Unchanged on exit.
*
* BETA (input) const double *
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input. Unchanged
* on exit.
*
* Y (input/output) double *
* On entry, Y points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( m - 1 ) * abs( INCY ) ) * sizeof( double[2] ),
* that contains the vector y. Before entry with BETA non-zero,
* the incremented array Y must contain the vector y. On exit,
* Y is overwritten by the updated vector y.
*
* INCY (input) const int
* On entry, INCY specifies the increment for the elements of Y.
* INCY must not be zero. Unchanged on exit.
*
* ---------------------------------------------------------------------
*/
/* ..
* .. Executable Statements ..
*
*/
if( ( M == 0 ) || ( N == 0 ) ||
( Mdzero( ALPHA[0], ALPHA[1] ) && Mdone( BETA[0], BETA[1] ) ) )
return;
if( Mdzero( ALPHA[0], ALPHA[1] ) )
{ Mzvscal( M, BETA, Y, INCY ); return; }
if( TRANS == AtlasNoTrans )
{
ATL_zrefgbmvN( M, N, KL, KU, ALPHA, A, LDA, X, INCX, BETA, Y, INCY );
}
else if( TRANS == AtlasConj )
{
ATL_zrefgbmvC( M, N, KL, KU, ALPHA, A, LDA, X, INCX, BETA, Y, INCY );
}
else if( TRANS == AtlasTrans )
{
ATL_zrefgbmvT( M, N, KL, KU, ALPHA, A, LDA, X, INCX, BETA, Y, INCY );
}
else
{
ATL_zrefgbmvH( M, N, KL, KU, ALPHA, A, LDA, X, INCX, BETA, Y, INCY );
}
/*
* End of ATL_zrefgbmv
*/
}
void ATL_zrefhpmv
(
const enum ATLAS_UPLO UPLO,
const int N,
const double * ALPHA,
const double * A,
const double * X,
const int INCX,
const double * BETA,
double * Y,
const int INCY
)
{
/*
* Purpose
* =======
*
* ATL_zrefhpmv performs the matrix-vector operation
*
* y := alpha * A * x + beta * y,
*
* where alpha and beta are scalars, x and y are n-element vectors and A
* is an n by n Hermitian matrix, supplied in packed form.
*
* Arguments
* =========
*
* UPLO (input) const enum ATLAS_UPLO
* On entry, UPLO specifies whether the upper or lower triangu-
* lar part of the matrix A is supplied in the packed array A
* as follows:
*
* UPLO = AtlasUpper The upper triangular part of A is
* supplied in A.
*
* UPLO = AtlasLower The lower triangular part of A is
* supplied in A.
*
* Unchanged on exit.
*
* N (input) const int
* On entry, N specifies the order of the matrix A. N must be at
* least zero. Unchanged on exit.
*
* ALPHA (input) const double *
* On entry, ALPHA specifies the scalar alpha. When ALPHA is
* supplied as zero then A and X need not be set on input. Un-
* changed on exit.
*
* A (input) const double *
* On entry, A points to an array of size equal to or greater
* than (( n*(n+1) ) / 2) * sizeof( double[2] ). Before entry
* with UPLO = AtlasUpper, the array A must contain the upper
* triangular part of the Hermitian matrix packed sequentially,
* column by column, so that A[ 0 ] contains a(0,0), A[ 1 ] and
* A[ 2 ] contain a(0,1) and a(1,1) respectively, and so on.
* Before entry with UPLO = AtlasLower, the array A must contain
* the lower triangular part of the Hermitian matrix packed se-
* quentially, column by column, so that A[ 0 ] contains a(0,0),
* A[ 1 ] and A[ 2 ] contain a(1,0) and a(2,0) respectively, and
* so on. Unchanged on exit.
* Note that the imaginary parts of the local entries corres-
* ponding to the diagonal elements of A need not be set and as-
* sumed to be zero. Unchanged on exit.
*
* X (input) const double *
* On entry, X points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCX ) ) * sizeof( double[2] ),
* that contains the vector x. Unchanged on exit.
*
* INCX (input) const int
* On entry, INCX specifies the increment for the elements of X.
* INCX must not be zero. Unchanged on exit.
*
* BETA (input) const double *
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input. Unchanged
* on exit.
*
* Y (input/output) double *
* On entry, Y points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCY ) ) * sizeof( double[2] ),
* that contains the vector y. Before entry with BETA non-zero,
* the incremented array Y must contain the vector y. On exit,
* Y is overwritten by the updated vector y.
*
* INCY (input) const int
* On entry, INCY specifies the increment for the elements of Y.
* INCY must not be zero. Unchanged on exit.
*
* ---------------------------------------------------------------------
*/
/* ..
* .. Executable Statements ..
*
*/
if( ( N == 0 ) ||
( Mdzero( ALPHA[0], ALPHA[1] ) && Mdone( BETA[0], BETA[1] ) ) ) return;
if( Mdzero( ALPHA[0], ALPHA[1] ) )
{ Mzvscal( N, BETA, Y, INCY ); return; }
if( UPLO == AtlasUpper )
{
ATL_zrefhpmvU( N, ALPHA, A, 1, X, INCX, BETA, Y, INCY );
}
else
{
ATL_zrefhpmvL( N, ALPHA, A, N, X, INCX, BETA, Y, INCY );
}
/*
* End of ATL_zrefhpmv
*/
}
void ATL_zrefsymm
(
const enum ATLAS_SIDE SIDE,
const enum ATLAS_UPLO UPLO,
const int M,
const int N,
const double * ALPHA,
const double * A,
const int LDA,
const double * B,
const int LDB,
const double * BETA,
double * C,
const int LDC
)
{
/*
* Purpose
* =======
*
* ATL_zrefsymm performs one of the matrix-matrix operations
*
* C := alpha * A * B + beta * C,
*
* or
*
* C := alpha * B * A + beta * C,
*
* where alpha and beta are scalars, A is a symmetric matrix and B and
* C are m by n matrices.
*
* Arguments
* =========
*
* SIDE (input) const enum ATLAS_SIDE
* On entry, SIDE specifies whether the symmetric matrix A
* appears on the left or right in the operation as follows:
*
* SIDE = AtlasLeft C := alpha * A * B + beta * C,
*
* SIDE = AtlasRight C := alpha * B * A + beta * C.
*
* Unchanged on exit.
*
* UPLO (input) const enum ATLAS_UPLO
* On entry, UPLO specifies whether the upper or lower triangu-
* lar part of the array A is to be referenced as follows:
*
* UPLO = AtlasUpper Only the upper triangular part of A
* is to be referenced.
*
* UPLO = AtlasLower Only the lower triangular part of A
* is to be referenced.
*
* Unchanged on exit.
*
* M (input) const int
* On entry, M specifies the number of rows of the matrix C.
* M must be at least zero. Unchanged on exit.
*
* N (input) const int
* On entry, N specifies the number of columns of the matrix C.
* N must be at least zero. Unchanged on exit.
*
* ALPHA (input) const double *
* On entry, ALPHA specifies the scalar alpha. When ALPHA is
* supplied as zero then the elements of the matrices A and B
* need not be set on input.
*
* A (input) const double *
* On entry, A points to an array of size equal to or greater
* than LDA * ka * sizeof( double[2] ), where ka is m when
* SIDE = AtlasLeft and is n otherwise. Before entry with
* SIDE = AtlasLeft, the m by m part of the array A must con-
* tain the symmetric matrix, such that when UPLO = AtlasUpper,
* the leading m by m upper triangular part of the array A must
* contain the upper triangular part of the symmetric matrix and
* the strictly lower triangular part of A is not referenced,
* and when UPLO = AtlasLower, the leading m by m lower trian-
* gular part of the array A must contain the lower triangular
* part of the symmetric matrix and the strictly upper triangu-
* lar part of A is not referenced.
* Before entry with SIDE = AtlasRight, the n by n part of
* the array A must contain the symmetric matrix, such that
* when UPLO = AtlasUpper, the leading n by n upper triangular
* part of the array A must contain the upper triangular part
* of the symmetric matrix and the strictly lower triangular
* part of A is not referenced, and when UPLO = AtlasLower,
* the leading n by n lower triangular part of the array A
* must contain the lower triangular part of the symmetric
* matrix and the strictly upper triangular part of A is not
* referenced. Unchanged on exit.
*
* LDA (input) const int
* On entry, LDA specifies the leading dimension of A as decla-
* red in the calling (sub) program. LDA must be at least
* MAX( 1, m ) when SIDE = AtlasLeft, and MAX( 1, n ) otherwise.
* Unchanged on exit.
*
* B (input) const double *
* On entry, B points to an array of size equal to or greater
* than LDB * n * sizeof( double[2] ). Before entry, the lea-
* ding m by n part of the array B must contain the matrix B.
* Unchanged on exit.
*
* LDB (input) const int
* On entry, LDB specifies the leading dimension of B as decla-
* red in the calling (sub) program. LDB must be at least
* MAX( 1, m ). wise. Unchanged on exit.
*
* BETA (input) const double *
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then the elements of the matrix C need
* not be set on input. Unchanged on exit.
*
* C (input/output) double *
* On entry, C points to an array of size equal to or greater
* than LDC * n * sizeof( double[2] ). Before entry, the lea-
* ding m by n part of the array C must contain the matrix C,
* except when beta is zero, in which case C need not be set on
* entry. On exit, the array C is overwritten by the m by n up-
* dated matrix.
*
* LDC (input) const int
* On entry, LDC specifies the leading dimension of A as decla-
* red in the calling (sub) program. LDC must be at least
* MAX( 1, m ). Unchanged on exit.
*
* ---------------------------------------------------------------------
*/
/* ..
* .. Executable Statements ..
*
*/
if( ( M == 0 ) || ( N == 0 ) || ( Mdzero( ALPHA[0], ALPHA[1] ) &&
Mdone ( BETA [0], BETA [1] ) ) ) return;
if( Mdzero( ALPHA[0], ALPHA[1] ) )
{
Mzgescal( M, N, BETA, C, LDC );
return;
}
if( SIDE == AtlasLeft )
{
if( UPLO == AtlasUpper )
{
ATL_zrefsymmLU( M, N, ALPHA, A, LDA, B, LDB, BETA, C, LDC );
}
else
{
ATL_zrefsymmLL( M, N, ALPHA, A, LDA, B, LDB, BETA, C, LDC );
}
}
else
{
if( UPLO == AtlasUpper )
{
ATL_zrefsymmRU( M, N, ALPHA, A, LDA, B, LDB, BETA, C, LDC );
}
else
{
ATL_zrefsymmRL( M, N, ALPHA, A, LDA, B, LDB, BETA, C, LDC );
}
}
/*
* End of ATL_zrefsymm
*/
}
void ATL_zrefher2k
(
const enum ATLAS_UPLO UPLO,
const enum ATLAS_TRANS TRANS,
const int N,
const int K,
const double * ALPHA,
const double * A,
const int LDA,
const double * B,
const int LDB,
const double BETA,
double * C,
const int LDC
)
{
/*
* Purpose
* =======
*
* ATL_zrefher2k performs one of the Hermitian rank 2k operations
*
* C := alpha * A * conjg( B )' + B * conjg( alpha * A )' + beta * C,
*
* or
*
* C := alpha * conjg( A' ) * B + conjg( alpha * B' ) * A + beta * C,
*
* where alpha and beta are scalars with beta real, C is an n by n
* Hermitian matrix and A and B are n by k matrices in the first case
* and k by n matrices in the second case.
*
* Arguments
* =========
*
* UPLO (input) const enum ATLAS_UPLO
* On entry, UPLO specifies whether the upper or lower triangu-
* lar part of the array C is to be referenced as follows:
*
* UPLO = AtlasUpper Only the upper triangular part of C
* is to be referenced.
*
* UPLO = AtlasLower Only the lower triangular part of C
* is to be referenced.
*
* Unchanged on exit.
*
* TRANS (input) const enum ATLAS_TRANS
* On entry, TRANS specifies the operation to be performed as
* follows:
*
* TRANS = AtlasNoTrans
* C := alpha * A * conjg( B' ) + B * conjg( alpha * A' ) +
* beta * C,
*
* TRANS = AtlasConjTrans
* C := alpha * conjg( A' ) * B + conjg( alpha * B' ) * A +
* beta * C.
*
* Unchanged on exit.
*
* N (input) const int
* On entry, N specifies the order of the matrix C. N must be at
* least zero. Unchanged on exit.
*
* K (input) const int
* On entry, with TRANS = AtlasNoTrans, K specifies the number
* of columns of the matrices A and B, and otherwise K specifies
* the number of rows of the matrices A and B. K must be at
* least zero. Unchanged on exit.
*
* ALPHA (input) const double *
* On entry, ALPHA specifies the scalar alpha. When ALPHA is
* supplied as zero then the entries of the matrices A and B
* need not be set on input. Unchanged on exit.
*
* A (input) const double *
* On entry, A points to an array of size equal to or greater
* than LDA * ka * sizeof( double[2] ), where ka is k when
* TRANS = AtlasNoTrans, and is n otherwise. Before entry with
* TRANS = AtlasNoTrans, the leading n by k part of the array A
* must contain the matrix A, otherwise the leading k by n part
* of the array A must contain the matrix A. Unchanged on exit.
*
* LDA (input) const int
* On entry, LDA specifies the leading dimension of A as decla-
* red in the calling (sub) program. LDA must be at least
* MAX( 1, n ) when TRANS = AtlasNoTrans, and MAX( 1, k ) other-
* wise. Unchanged on exit.
*
* B (input) const double *
* On entry, B points to an array of size equal to or greater
* than LDB * kb * sizeof( double[2] ), where kb is k when
* TRANS = AtlasNoTrans, and is n otherwise. Before entry with
* TRANS = AtlasNoTrans, the leading n by k part of the array B
* must contain the matrix B, otherwise the leading k by n part
* of the array B must contain the matrix B. Unchanged on exit.
*
* LDB (input) const int
* On entry, LDB specifies the leading dimension of B as decla-
* red in the calling (sub) program. LDB must be at least
* MAX( 1, n ) when TRANS = AtlasNoTrans, and MAX( 1, k ) other-
* wise. Unchanged on exit.
*
* BETA (input) const double
* On entry, BETA specifies the real scalar beta. When BETA is
* supplied as zero then the entries of the matrix C need not
* be set on input. Unchanged on exit.
*
* C (input/output) double *
* On entry, C points to an array of size equal to or greater
* than LDC * n * sizeof( double[2] ), Before entry with
* UPLO = AtlasUpper, the leading n by n upper triangular part
* of the array C must contain the upper triangular part of the
* Hermitian matrix and the strictly lower triangular part of C
* is not referenced. On exit, the upper triangular part of the
* array C is overwritten by the upper triangular part of the
* updated matrix. Before entry with UPLO = AtlasLower, the
* leading n by n lower triangular part of the array C must con-
* tain the lower triangular part of the Hermitian matrix and
* the strictly upper triangular part of C is not referenced. On
* exit, the lower triangular part of the array C is overwritten
* by the lower triangular part of the updated matrix.
* Note that the imaginary parts of the diagonal elements of C
* need not be set, they are assumed to be zero, and on exit
* they are set to zero.
*
* LDC (input) const int
* On entry, LDC specifies the leading dimension of A as decla-
* red in the calling (sub) program. LDC must be at least
* MAX( 1, n ). Unchanged on exit.
*
* ---------------------------------------------------------------------
*/
/*
* .. Local Variables ..
*/
int i, icij, j, jcj, ldc2 = ( LDC << 1 ),
ldcp12 = ( ( LDC + 1 ) << 1 );
/* ..
* .. Executable Statements ..
*
*/
if( ( N == 0 ) || ( ( Mdzero( ALPHA[0], ALPHA[1] ) || ( K == 0 ) ) &&
( BETA == ATL_dONE ) ) )
return;
if( Mdzero( ALPHA[0], ALPHA[1] ) )
{
if( UPLO == AtlasUpper )
{
if( BETA == ATL_dZERO )
{
for( j = 0, jcj = 0; j < N; j++, jcj += ldc2 )
{
for( i = 0, icij = jcj; i <= j; i++, icij += 2 )
{ Mset( ATL_dZERO, ATL_dZERO, C[icij], C[icij+1] ); }
}
}
else if( BETA != ATL_dONE )
{
for( j = 0, jcj = 0; j < N; j++, jcj += ldc2 )
{
for( i = 0, icij = jcj; i < j; i++, icij += 2 )
{ Mset( BETA * C[icij], BETA * C[icij+1], C[icij], C[icij+1] ); }
Mset( BETA * C[icij], ATL_dZERO, C[icij], C[icij+1] );
}
}
}
else
{
if( BETA == ATL_dZERO )
{
for( j = 0, jcj = 0; j < N; j++, jcj += ldcp12 )
{
for( i = j, icij = jcj; i < N; i++, icij += 2 )
{ Mset( ATL_dZERO, ATL_dZERO, C[icij], C[icij+1] ); }
}
}
else if( BETA != ATL_dONE )
{
for( j = 0, jcj = 0; j < N; j++, jcj += ldcp12 )
{
Mset( BETA * C[jcj], ATL_dZERO, C[jcj], C[jcj+1] );
for( i = j+1, icij = jcj+2; i < N; i++, icij += 2 )
{ Mset( BETA * C[icij], BETA * C[icij+1], C[icij], C[icij+1] ); }
}
}
}
return;
}
if( UPLO == AtlasUpper )
{
if( TRANS == AtlasNoTrans )
{ ATL_zrefher2kUN( N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC ); }
else
{ ATL_zrefher2kUC( N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC ); }
}
else
{
if( TRANS == AtlasNoTrans )
{ ATL_zrefher2kLN( N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC ); }
else
{ ATL_zrefher2kLC( N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC ); }
}
/*
* End of ATL_zrefher2k
*/
}
void ATL_zreftrmm
(
const enum ATLAS_SIDE SIDE,
const enum ATLAS_UPLO UPLO,
const enum ATLAS_TRANS TRANS,
const enum ATLAS_DIAG DIAG,
const int M,
const int N,
const double * ALPHA,
const double * A,
const int LDA,
double * B,
const int LDB
)
{
/*
* Purpose
* =======
*
* ATL_zreftrmm performs one of the matrix-matrix operations
*
* B := alpha * op( A ) * B, or B := alpha * B * op( A ),
*
* where alpha is a scalar, B is an m by n matrix, A is a unit, or non-
* unit, upper or lower triangular matrix and op( X ) is one of
*
* op( X ) = X or op( X ) = X' or op( X ) = conjg( X' ).
*
* Arguments
* =========
*
* SIDE (input) const enum ATLAS_SIDE
* On entry, SIDE specifies whether op( A ) multiplies B from
* the left or right as follows:
*
* SIDE = AtlasLeft B := alpha * op( A )* B,
*
* SIDE = AtlasRight B := alpha * B * op( A ).
*
* Unchanged on exit.
*
* UPLO (input) const enum ATLAS_UPLO
* On entry, UPLO specifies whether the matrix is an upper or
* lower triangular matrix as follows:
*
* UPLO = AtlasUpper A is an upper triangular matrix.
*
* UPLO = AtlasLower A is a lower triangular matrix.
*
* Unchanged on exit.
*
* TRANSA (input) const enum ATLAS_TRANS
* On entry, TRANSA specifies the form of op( A ) to be used in
* the matrix multiplication as follows:
*
* TRANSA = AtlasNoTrans op( A ) = A,
*
* TRANSA = AtlasTrans op( A ) = A',
*
* TRANSA = AtlasConjTrans op( A ) = conjg( A' ).
*
* Unchanged on exit.
*
* DIAG (input) const enum ATLAS_DIAG
* On entry, DIAG specifies whether or not A is unit triangu-
* lar as follows:
*
* DIAG = AtlasUnit A is assumed to be unit triangular,
*
* DIAG = AtlasNonUnit A is not assumed to be unit trian-
* gular.
*
* Unchanged on exit.
*
* M (input) const int
* On entry, M specifies the number of rows of the matrix B.
* M must be at least zero. Unchanged on exit.
*
* N (input) const int
* On entry, N specifies the number of columns of the matrix B.
* N must be at least zero. Unchanged on exit.
*
* ALPHA (input) const double *
* On entry, ALPHA specifies the scalar alpha. When ALPHA is
* supplied as zero then the elements of the matrix B need not
* be set on input. Unchanged on exit.
*
* A (input) const double *
* On entry, A points to an array of size equal to or greater
* than LDA * k * sizeof( double[2] ), where k is m when
* SIDE = AtlasLeft and is n otherwise. Before entry with
* UPLO = AtlasUpper, the leading k by k upper triangular part
* of the array A must contain the upper triangular matrix and
* the strictly lower triangular part of A is not referenced.
* Before entry with UPLO = AtlasLower, the leading k by k lower
* triangular part of the array A must contain the lower trian-
* gular matrix and the strictly upper triangular part of A is
* not referenced.
* Note that when DIAG = AtlasUnit, the diagonal elements of
* A are not referenced either, but are assumed to be unity.
* Unchanged on exit.
*
* LDA (input) const int
* On entry, LDA specifies the leading dimension of A as decla-
* red in the calling (sub) program. LDA must be at least
* MAX( 1, m ) when SIDE = AtlasLeft, and MAX( 1, n ) otherwise.
* Unchanged on exit.
*
* B (input/output) double *
* On entry, B points to an array of size equal to or greater
* than LDB * n * sizeof( double[2] ). Before entry, the lea-
* ding m by n part of the array B must contain the matrix B,
* except when beta is zero, in which case B need not be set on
* entry. On exit, the array B is overwritten by the m by n up-
* dated matrix.
*
* LDB (input) const int
* On entry, LDB specifies the leading dimension of B as decla-
* red in the calling (sub) program. LDB must be at least
* MAX( 1, m ). Unchanged on exit.
*
* ---------------------------------------------------------------------
*/
/* ..
* .. Executable Statements ..
*
*/
if( ( M == 0 ) || ( N == 0 ) ) return;
if( Mdzero( ALPHA[0], ALPHA[1] ) )
{ Mzgescal( M, N, ALPHA, B, LDB ); return; }
if( SIDE == AtlasLeft )
{
if( UPLO == AtlasUpper )
{
if( TRANS == AtlasNoTrans )
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmLUNN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmLUNU( M, N, ALPHA, A, LDA, B, LDB ); }
}
else if( TRANS == AtlasTrans )
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmLUTN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmLUTU( M, N, ALPHA, A, LDA, B, LDB ); }
}
else
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmLUCN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmLUCU( M, N, ALPHA, A, LDA, B, LDB ); }
}
}
else
{
if( TRANS == AtlasNoTrans )
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmLLNN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmLLNU( M, N, ALPHA, A, LDA, B, LDB ); }
}
else if( TRANS == AtlasTrans )
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmLLTN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmLLTU( M, N, ALPHA, A, LDA, B, LDB ); }
}
else
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmLLCN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmLLCU( M, N, ALPHA, A, LDA, B, LDB ); }
}
}
}
else
{
if( UPLO == AtlasUpper )
{
if( TRANS == AtlasNoTrans )
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmRUNN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmRUNU( M, N, ALPHA, A, LDA, B, LDB ); }
}
else if( TRANS == AtlasTrans )
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmRUTN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmRUTU( M, N, ALPHA, A, LDA, B, LDB ); }
}
else
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmRUCN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmRUCU( M, N, ALPHA, A, LDA, B, LDB ); }
}
}
else
{
if( TRANS == AtlasNoTrans )
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmRLNN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmRLNU( M, N, ALPHA, A, LDA, B, LDB ); }
}
else if( TRANS == AtlasTrans )
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmRLTN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmRLTU( M, N, ALPHA, A, LDA, B, LDB ); }
}
else
{
if( DIAG == AtlasNonUnit )
{ ATL_zreftrmmRLCN( M, N, ALPHA, A, LDA, B, LDB ); }
else { ATL_zreftrmmRLCU( M, N, ALPHA, A, LDA, B, LDB ); }
}
}
}
/*
* End of ATL_zreftrmm
*/
}
void ATL_zrefgemv
(
const enum ATLAS_TRANS TRANS,
const int M,
const int N,
const double * ALPHA,
const double * A,
const int LDA,
const double * X,
const int INCX,
const double * BETA,
double * Y,
const int INCY
)
{
/*
* Purpose
* =======
*
* ATL_zrefgemv performs one of the matrix-vector operations
*
* y := alpha * op( A ) * x + beta * y,
*
* where op( X ) is one of
*
* op( X ) = X or op( X ) = conjg( X ) or
*
* op( X ) = X' or op( X ) = conjg( X' ).
*
* where alpha and beta are scalars, x and y are vectors and op( A ) is
* an m by n matrix.
*
* Arguments
* =========
*
* TRANS (input) const enum ATLAS_TRANS
* On entry, TRANS specifies the operation to be performed as
* follows:
*
* TRANS = AtlasNoTrans y := alpha*A *x + beta*y,
*
* TRANS = AtlasConj y := alpha*conjg( A )*x + beta*y,
*
* TRANS = AtlasTrans y := alpha*A'*x + beta*y,
*
* TRANS = AtlasConjTrans y := alpha*conjg( A' )*x + beta*y.
*
* Unchanged on exit.
*
* M (input) const int
* On entry, M specifies the number of rows of the matrix A
* when TRANS = AtlasNoTrans or TRANS = AtlasConj, and the num-
* ber of columns of the matrix A otherwise. M must be at least
* zero. Unchanged on exit.
*
* N (input) const int
* On entry, N specifies the number of columns of the matrix A
* when TRANS = AtlasNoTrans or TRANS = AtlasConj, and the num-
* ber of rows of the matrix A otherwise. N must be at least ze-
* ro. Unchanged on exit.
*
* ALPHA (input) const double *
* On entry, ALPHA specifies the scalar alpha. When ALPHA is
* supplied as zero then A and X need not be set on input. Un-
* changed on exit.
*
* A (input) const double *
* On entry, A points to an array of size equal to or greater
* than LDA * ka * sizeof( double[2] ), where ka is n when
* TRANS = AtlasNotrans or TRANS = AtlasConj, and m otherwise.
* Before entry, when TRANS = AtlasNotrans or TRANS = AtlasConj,
* the leading m by n part of the array A must contain the ma-
* trix coefficients, and otherwise the leading n by m part of
* the array A must contain the matrix coefficients. Unchanged
* on exit.
*
* LDA (input) const int
* On entry, LDA specifies the leading dimension of A as decla-
* red in the calling (sub) program. LDA must be at least
* MAX( 1, m ) when TRANS = AtlasNotrans or TRANS = AtlasConj,
* and MAX( 1, n ) otherwise. Unchanged on exit.
*
* X (input) const double *
* On entry, X points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCX ) ) * sizeof( double[2] ),
* that contains the vector x. Unchanged on exit.
*
* INCX (input) const int
* On entry, INCX specifies the increment for the elements of X.
* INCX must not be zero. Unchanged on exit.
*
* BETA (input) const double *
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input. Unchanged
* on exit.
*
* Y (input/output) double *
* On entry, Y points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( m - 1 ) * abs( INCY ) ) * sizeof( double[2] ),
* that contains the vector y. Before entry with BETA non-zero,
* the incremented array Y must contain the vector y. On exit,
* Y is overwritten by the updated vector y.
*
* INCY (input) const int
* On entry, INCY specifies the increment for the elements of Y.
* INCY must not be zero. Unchanged on exit.
*
* ---------------------------------------------------------------------
*/
/* ..
* .. Executable Statements ..
*
*/
if( ( M == 0 ) || ( N == 0 ) ||
( Mdzero( ALPHA[0], ALPHA[1] ) && Mdone( BETA[0], BETA[1] ) ) )
return;
if( Mdzero( ALPHA[0], ALPHA[1] ) )
{ Mzvscal( M, BETA, Y, INCY ); return; }
if( TRANS == AtlasNoTrans )
{ ATL_zrefgemvN( M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY ); }
else if( TRANS == AtlasConj )
{ ATL_zrefgemvC( M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY ); }
else if( TRANS == AtlasTrans )
{ ATL_zrefgemvT( M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY ); }
else
{ ATL_zrefgemvH( M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY ); }
/*
* End of ATL_zrefgemv
*/
}
void ATL_zrefhbmv
(
const enum ATLAS_UPLO UPLO,
const int N,
const int K,
const double * ALPHA,
const double * A,
const int LDA,
const double * X,
const int INCX,
const double * BETA,
double * Y,
const int INCY
)
{
/*
* Purpose
* =======
*
* ATL_zrefhbmv performs the matrix-vector operation
*
* y := alpha * A * x + beta * y,
*
* where alpha and beta are scalars, x and y are n-element vectors and A
* is an n by n Hermitian band matrix, with k super-diagonals.
*
* Arguments
* =========
*
* UPLO (input) const enum ATLAS_UPLO
* On entry, UPLO specifies whether the upper or lower triangu-
* lar part of the band matrix A is being supplied as follows:
*
* UPLO = AtlasUpper The upper triangular part of A is
* being supplied.
*
* UPLO = AtlasLower The lower triangular part of A is
* being supplied.
*
* Unchanged on exit.
*
* N (input) const int
* On entry, N specifies the order of the matrix A. N must be at
* least zero. Unchanged on exit.
*
* K (input) const int
* On entry, K specifies the number of super-diagonals of the
* matrix A. K must satisfy 0 <= K. Unchanged on exit.
*
* ALPHA (input) const double *
* On entry, ALPHA specifies the scalar alpha. When ALPHA is
* supplied as zero then A and X need not be set on input. Un-
* changed on exit.
*
* A (input) const double *
* On entry, A points to an array of size equal to or greater
* than LDA * n * sizeof( double[2] ). Before entry with
* UPLO = AtlasUpper, the leading ( k + 1 ) by n part of the ar-
* ray A must contain the upper triangular band part of the
* Hermitian matrix, supplied column by column, with the leading
* diagonal of the matrix in row k of the array, the first su-
* per-diagonal starting at position 1 in row k-1, and so on.
* The top left k by k triangle of the array A is not referen-
* ced. Unchanged on exit.
* The following program segment will transfer the upper trian-
* gular part of a Hermitian band matrix from conventional full
* matrix storage to band storage:
*
* for( j = 0; j < n; j++ )
* {
* m = k - j;
* for( i = ( m < 0 ? -m : 0 ); i < j; i++ )
* {
* a[((m+i+j*LDA)<<1)+0] = real( matrix( i, j ) );
* a[((m+i+j*LDA)<<1)+1] = imag( matrix( i, j ) );
* }
* }
*
* Before entry with UPLO = AtlasLower, the leading ( k + 1 ) by
* n part of the array A must contain the lower triangular band
* part of the Hermitian matrix, supplied column by column, with
* the leading diagonal of the matrix in row 0 of the array, the
* first sub-diagonal starting at position 0 in row 1, and so
* on. The bottom right k by k triangle of the array A is not
* referenced. Unchanged on exit.
* The following program segment will transfer the lower trian-
* gular part of a Hermitian band matrix from conventional full
* matrix storage to band storage:
*
* for( j = 0; j < n; j++ )
* {
* i1 = ( n > j + k + 1 ? j + k + 1 : n );
* for( i = j; i < i1; i++ )
* {
* a[((i-j+j*LDA)<<1)+0] = real( matrix( i, j ) );
* a[((i-j+j*LDA)<<1)+1] = imag( matrix( i, j ) );
* }
* }
*
* Note that the imaginary parts of the local entries corres-
* ponding to the diagonal elements of A need not be set and as-
* sumed to be zero. Unchanged on exit.
*
* LDA (input) const int
* On entry, LDA specifies the leading dimension of A as decla-
* red in the calling (sub) program. LDA must be at least
* k + 1. Unchanged on exit.
*
* X (input) const double *
* On entry, X points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCX ) ) * sizeof( double[2] ),
* that contains the vector x. Unchanged on exit.
*
* INCX (input) const int
* On entry, INCX specifies the increment for the elements of X.
* INCX must not be zero. Unchanged on exit.
*
* BETA (input) const double *
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input. Unchanged
* on exit.
*
* Y (input/output) double *
* On entry, Y points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCY ) ) * sizeof( double[2] ),
* that contains the vector y. Before entry with BETA non-zero,
* the incremented array Y must contain the vector y. On exit,
* Y is overwritten by the updated vector y.
*
* INCY (input) const int
* On entry, INCY specifies the increment for the elements of Y.
* INCY must not be zero. Unchanged on exit.
*
* ---------------------------------------------------------------------
*/
/* ..
* .. Executable Statements ..
*
*/
if( ( N == 0 ) ||
( Mdzero( ALPHA[0], ALPHA[1] ) && Mdone( BETA[0], BETA[1] ) ) ) return;
if( Mdzero( ALPHA[0], ALPHA[1] ) )
{ Mzvscal( N, BETA, Y, INCY ); return; }
if( UPLO == AtlasUpper )
{
ATL_zrefhbmvU( N, K, ALPHA, A, LDA, X, INCX, BETA, Y, INCY );
}
else
{
ATL_zrefhbmvL( N, K, ALPHA, A, LDA, X, INCX, BETA, Y, INCY );
}
/*
* End of ATL_zrefhbmv
*/
}
void ATL_zrefher2
(
const enum ATLAS_UPLO UPLO,
const int N,
const double * ALPHA,
const double * X,
const int INCX,
const double * Y,
const int INCY,
double * A,
const int LDA
)
{
/*
* Purpose
* =======
*
* ATL_zrefher2 performs the Hermitian rank 2 operation
*
* A := alpha * x * conjg( y' ) + y * conjg( alpha * x' ) + A,
*
* where alpha is a scalar, x and y are n-element vectors and A is an n
* by n Hermitian matrix.
*
* Arguments
* =========
*
* UPLO (input) const enum ATLAS_UPLO
* On entry, UPLO specifies whether the upper or lower triangu-
* lar part of the array A is to be referenced as follows:
*
* UPLO = AtlasUpper Only the upper triangular part of A
* is to be referenced.
*
* UPLO = AtlasLower Only the lower triangular part of A
* is to be referenced.
*
* Unchanged on exit.
*
* N (input) const int
* On entry, N specifies the order of the matrix A. N must be at
* least zero. Unchanged on exit.
*
* ALPHA (input) const double *
* On entry, ALPHA specifies the scalar alpha. When ALPHA is
* supplied as zero then the arrays X and Y need not be set on
* input. Unchanged on exit.
*
* X (input) const double *
* On entry, X points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCX ) ) * sizeof( double[2] ),
* that contains the vector x. Unchanged on exit.
*
* INCX (input) const int
* On entry, INCX specifies the increment for the elements of X.
* INCX must not be zero. Unchanged on exit.
*
* Y (input) const double *
* On entry, Y points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCY ) ) * sizeof( double[2] ),
* that contains the vector y. Unchanged on exit.
*
* INCY (input) const int
* On entry, INCY specifies the increment for the elements of Y.
* INCY must not be zero. Unchanged on exit.
*
* A (input/output) double *
* On entry, A points to an array of size equal to or greater
* than LDA * n * sizeof( double[2] ). Before entry with
* UPLO = AtlasUpper, the leading n by n upper triangular part
* of the array A must contain the upper triangular part of the
* Hermitian matrix and the strictly lower triangular part of A
* is not referenced. On exit, the upper triangular part of the
* array A is overwritten by the upper triangular part of the
* updated matrix. With UPLO = AtlasLower, the leading n by n
* lower triangular part of the array A must contain the lower
* triangular part of the Hermitian matrix and the strictly up-
* per triangular part of A is not referenced.
* Note that the imaginary parts of the diagonal elements need
* not be set, they are assumed to be zero, and on exit they are
* set to zero.
*
* LDA (input) const int
* On entry, LDA specifies the leading dimension of A as decla-
* red in the calling (sub) program. LDA must be at least
* MAX( 1, n ). Unchanged on exit.
*
* ---------------------------------------------------------------------
*/
/* ..
* .. Executable Statements ..
*
*/
if( ( N == 0 ) || Mdzero( ALPHA[0], ALPHA[1] ) ) return;
if( UPLO == AtlasUpper )
{
ATL_zrefher2U( N, ALPHA, X, INCX, Y, INCY, A, LDA );
}
else
{
ATL_zrefher2L( N, ALPHA, X, INCX, Y, INCY, A, LDA );
}
/*
* End of ATL_zrefher2
*/
}
void ATL_zrefhemv
(
const enum ATLAS_UPLO UPLO,
const int N,
const double * ALPHA,
const double * A,
const int LDA,
const double * X,
const int INCX,
const double * BETA,
double * Y,
const int INCY
)
{
/*
* Purpose
* =======
*
* ATL_zrefhemv performs the matrix-vector operation
*
* y := alpha * A * x + beta * y,
*
* where alpha and beta are scalars, x and y are n-element vectors and A
* is an n by n Hermitian matrix.
*
* Arguments
* =========
*
* UPLO (input) const enum ATLAS_UPLO
* On entry, UPLO specifies whether the upper or lower triangu-
* lar part of the array A is to be referenced as follows:
*
* UPLO = AtlasUpper Only the upper triangular part of A
* is to be referenced.
*
* UPLO = AtlasLower Only the lower triangular part of A
* is to be referenced.
*
* Unchanged on exit.
*
* N (input) const int
* On entry, N specifies the order of the matrix A. N must be at
* least zero. Unchanged on exit.
*
* ALPHA (input) const double *
* On entry, ALPHA specifies the scalar alpha. When ALPHA is
* supplied as zero then A and X need not be set on input. Un-
* changed on exit.
*
* A (input) const double *
* On entry, A points to an array of size equal to or greater
* than LDA * n * sizeof( double[2] ). Before entry with
* UPLO = AtlasUpper, the leading n by n upper triangular part
* of the array A must contain the upper triangular part of the
* Hermitian matrix and the strictly lower triangular part of
* A is not referenced. Before entry with UPLO = AtlasLower, the
* leading n by n lower triangular part of the array A must
* contain the lower triangular part of the Hermitian matrix and
* the strictly upper triangular part of A is not referenced.
* Unchanged on exit.
* Note that the imaginary parts of the local entries corres-
* ponding to the diagonal elements of A need not be set and as-
* sumed to be zero.
*
* LDA (input) const int
* On entry, LDA specifies the leading dimension of A as decla-
* red in the calling (sub) program. LDA must be at least
* MAX( 1, n ). Unchanged on exit.
*
* X (input) const double *
* On entry, X points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCX ) ) * sizeof( double[2] ),
* that contains the vector x. Unchanged on exit.
*
* INCX (input) const int
* On entry, INCX specifies the increment for the elements of X.
* INCX must not be zero. Unchanged on exit.
*
* BETA (input) const double *
* On entry, BETA specifies the scalar beta. When BETA is
* supplied as zero then Y need not be set on input. Unchanged
* on exit.
*
* Y (input/output) double *
* On entry, Y points to the first entry to be accessed of an
* incremented array of size equal to or greater than
* ( 1 + ( n - 1 ) * abs( INCY ) ) * sizeof( double[2] ),
* that contains the vector y. Before entry with BETA non-zero,
* the incremented array Y must contain the vector y. On exit,
* Y is overwritten by the updated vector y.
*
* INCY (input) const int
* On entry, INCY specifies the increment for the elements of Y.
* INCY must not be zero. Unchanged on exit.
*
* ---------------------------------------------------------------------
*/
/* ..
* .. Executable Statements ..
*
*/
if( ( N == 0 ) ||
( Mdzero( ALPHA[0], ALPHA[1] ) && Mdone( BETA[0], BETA[1] ) ) ) return;
if( Mdzero( ALPHA[0], ALPHA[1] ) )
{ Mzvscal( N, BETA, Y, INCY ); return; }
if( UPLO == AtlasUpper )
{
ATL_zrefhemvU( N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY );
}
else
{
ATL_zrefhemvL( N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY );
}
/*
* End of ATL_zrefhemv
*/
}
