void F77_strmv(int *order, char *uplow, char *transp, char *diagn,
int *n, float *a, int *lda, float *x, int *incx) {
float *A;
int i,j,LDA;
enum CBLAS_TRANSPOSE trans;
enum CBLAS_UPLO uplo;
enum CBLAS_DIAG diag;
get_transpose_type(transp,&trans);
get_uplo_type(uplow,&uplo);
get_diag_type(diagn,&diag);
if (*order == TEST_ROW_MJR) {
LDA = *n+1;
A = ( float* )malloc( (*n)*LDA*sizeof( float ) );
for( i=0; i<*n; i++ )
for( j=0; j<*n; j++ )
A[ LDA*i+j ]=a[ (*lda)*j+i ];
cblas_strmv(CblasRowMajor, uplo, trans, diag, *n, A, LDA, x, *incx);
free(A);
}
else if (*order == TEST_COL_MJR)
cblas_strmv(CblasColMajor, uplo, trans, diag, *n, a, *lda, x, *incx);
else {
cblas_strmv(UNDEFINED, uplo, trans, diag, *n, a, *lda, x, *incx);
}
}
void F77_ctrsv(int *order, char *uplow, char *transp, char *diagn,
int *n, CBLAS_TEST_COMPLEX *a, int *lda, CBLAS_TEST_COMPLEX *x,
int *incx) {
CBLAS_TEST_COMPLEX *A;
int i,j,LDA;
enum CBLAS_TRANSPOSE trans;
enum CBLAS_UPLO uplo;
enum CBLAS_DIAG diag;
get_transpose_type(transp,&trans);
get_uplo_type(uplow,&uplo);
get_diag_type(diagn,&diag);
if (*order == TEST_ROW_MJR) {
LDA = *n+1;
A =(CBLAS_TEST_COMPLEX* )malloc((*n)*LDA*sizeof(CBLAS_TEST_COMPLEX ) );
for( i=0; i<*n; i++ )
for( j=0; j<*n; j++ ) {
A[ LDA*i+j ].real=a[ (*lda)*j+i ].real;
A[ LDA*i+j ].imag=a[ (*lda)*j+i ].imag;
}
cblas_ctrsv(CblasRowMajor, uplo, trans, diag, *n, A, LDA, x, *incx );
free(A);
}
else if (*order == TEST_COL_MJR)
cblas_ctrsv(CblasColMajor, uplo, trans, diag, *n, a, *lda, x, *incx );
else
cblas_ctrsv(UNDEFINED, uplo, trans, diag, *n, a, *lda, x, *incx );
}
void F77_cgemv(int *order, char *transp, int *m, int *n,
const void *alpha,
CBLAS_TEST_COMPLEX *a, int *lda, const void *x, int *incx,
const void *beta, void *y, int *incy) {
CBLAS_TEST_COMPLEX *A;
int i,j,LDA;
enum CBLAS_TRANSPOSE trans;
get_transpose_type(transp, &trans);
if (*order == TEST_ROW_MJR) {
LDA = *n+1;
A = (CBLAS_TEST_COMPLEX *)malloc( (*m)*LDA*sizeof( CBLAS_TEST_COMPLEX) );
for( i=0; i<*m; i++ )
for( j=0; j<*n; j++ ){
A[ LDA*i+j ].real=a[ (*lda)*j+i ].real;
A[ LDA*i+j ].imag=a[ (*lda)*j+i ].imag;
}
cblas_cgemv( CblasRowMajor, trans, *m, *n, alpha, A, LDA, x, *incx,
beta, y, *incy );
free(A);
}
else if (*order == TEST_COL_MJR)
cblas_cgemv( CblasColMajor, trans,
*m, *n, alpha, a, *lda, x, *incx, beta, y, *incy );
else
cblas_cgemv( UNDEFINED, trans,
*m, *n, alpha, a, *lda, x, *incx, beta, y, *incy );
}
void F77_sgemv(int *order, char *transp, int *m, int *n, float *alpha,
float *a, int *lda, float *x, int *incx, float *beta,
float *y, int *incy ) {
float *A;
int i,j,LDA;
enum CBLAS_TRANSPOSE trans;
get_transpose_type(transp, &trans);
if (*order == TEST_ROW_MJR) {
LDA = *n+1;
A = ( float* )malloc( (*m)*LDA*sizeof( float ) );
for( i=0; i<*m; i++ )
for( j=0; j<*n; j++ )
A[ LDA*i+j ]=a[ (*lda)*j+i ];
cblas_sgemv( CblasRowMajor, trans,
*m, *n, *alpha, A, LDA, x, *incx, *beta, y, *incy );
free(A);
}
else if (*order == TEST_COL_MJR)
cblas_sgemv( CblasColMajor, trans,
*m, *n, *alpha, a, *lda, x, *incx, *beta, y, *incy );
else
cblas_sgemv( UNDEFINED, trans,
*m, *n, *alpha, a, *lda, x, *incx, *beta, y, *incy );
}
void F77_ctrsm(int *layout, char *rtlf, char *uplow, char *transp, char *diagn,
int *m, int *n, CBLAS_TEST_COMPLEX *alpha, CBLAS_TEST_COMPLEX *a,
int *lda, CBLAS_TEST_COMPLEX *b, int *ldb) {
int i,j,LDA,LDB;
CBLAS_TEST_COMPLEX *A, *B;
CBLAS_SIDE side;
CBLAS_DIAG diag;
CBLAS_UPLO uplo;
CBLAS_TRANSPOSE trans;
get_uplo_type(uplow,&uplo);
get_transpose_type(transp,&trans);
get_diag_type(diagn,&diag);
get_side_type(rtlf,&side);
if (*layout == TEST_ROW_MJR) {
if (side == CblasLeft) {
LDA = *m+1;
A=(CBLAS_TEST_COMPLEX* )malloc( (*m)*LDA*sizeof(CBLAS_TEST_COMPLEX ) );
for( i=0; i<*m; i++ )
for( j=0; j<*m; j++ ) {
A[i*LDA+j].real=a[j*(*lda)+i].real;
A[i*LDA+j].imag=a[j*(*lda)+i].imag;
}
}
else{
LDA = *n+1;
A=(CBLAS_TEST_COMPLEX* )malloc((*n)*LDA*sizeof(CBLAS_TEST_COMPLEX));
for( i=0; i<*n; i++ )
for( j=0; j<*n; j++ ) {
A[i*LDA+j].real=a[j*(*lda)+i].real;
A[i*LDA+j].imag=a[j*(*lda)+i].imag;
}
}
LDB = *n+1;
B=(CBLAS_TEST_COMPLEX* )malloc((*m)*LDB*sizeof(CBLAS_TEST_COMPLEX));
for( i=0; i<*m; i++ )
for( j=0; j<*n; j++ ) {
B[i*LDB+j].real=b[j*(*ldb)+i].real;
B[i*LDB+j].imag=b[j*(*ldb)+i].imag;
}
cblas_ctrsm(CblasRowMajor, side, uplo, trans, diag, *m, *n, alpha,
A, LDA, B, LDB );
for( j=0; j<*n; j++ )
for( i=0; i<*m; i++ ) {
b[j*(*ldb)+i].real=B[i*LDB+j].real;
b[j*(*ldb)+i].imag=B[i*LDB+j].imag;
}
free(A);
free(B);
}
else if (*layout == TEST_COL_MJR)
cblas_ctrsm(CblasColMajor, side, uplo, trans, diag, *m, *n, alpha,
a, *lda, b, *ldb);
else
cblas_ctrsm(UNDEFINED, side, uplo, trans, diag, *m, *n, alpha,
a, *lda, b, *ldb);
}
void F77_csyrk(int *layout, char *uplow, char *transp, int *n, int *k,
CBLAS_TEST_COMPLEX *alpha, CBLAS_TEST_COMPLEX *a, int *lda,
CBLAS_TEST_COMPLEX *beta, CBLAS_TEST_COMPLEX *c, int *ldc ) {
int i,j,LDA,LDC;
CBLAS_TEST_COMPLEX *A, *C;
CBLAS_UPLO uplo;
CBLAS_TRANSPOSE trans;
get_uplo_type(uplow,&uplo);
get_transpose_type(transp,&trans);
if (*layout == TEST_ROW_MJR) {
if (trans == CblasNoTrans) {
LDA = *k+1;
A=(CBLAS_TEST_COMPLEX* )malloc((*n)*LDA*sizeof(CBLAS_TEST_COMPLEX));
for( i=0; i<*n; i++ )
for( j=0; j<*k; j++ ) {
A[i*LDA+j].real=a[j*(*lda)+i].real;
A[i*LDA+j].imag=a[j*(*lda)+i].imag;
}
}
else{
LDA = *n+1;
A=(CBLAS_TEST_COMPLEX* )malloc((*k)*LDA*sizeof(CBLAS_TEST_COMPLEX ) );
for( i=0; i<*k; i++ )
for( j=0; j<*n; j++ ) {
A[i*LDA+j].real=a[j*(*lda)+i].real;
A[i*LDA+j].imag=a[j*(*lda)+i].imag;
}
}
LDC = *n+1;
C=(CBLAS_TEST_COMPLEX* )malloc((*n)*LDC*sizeof(CBLAS_TEST_COMPLEX ) );
for( i=0; i<*n; i++ )
for( j=0; j<*n; j++ ) {
C[i*LDC+j].real=c[j*(*ldc)+i].real;
C[i*LDC+j].imag=c[j*(*ldc)+i].imag;
}
cblas_csyrk(CblasRowMajor, uplo, trans, *n, *k, alpha, A, LDA, beta,
C, LDC );
for( j=0; j<*n; j++ )
for( i=0; i<*n; i++ ) {
c[j*(*ldc)+i].real=C[i*LDC+j].real;
c[j*(*ldc)+i].imag=C[i*LDC+j].imag;
}
free(A);
free(C);
}
else if (*layout == TEST_COL_MJR)
cblas_csyrk(CblasColMajor, uplo, trans, *n, *k, alpha, a, *lda, beta,
c, *ldc );
else
cblas_csyrk(UNDEFINED, uplo, trans, *n, *k, alpha, a, *lda, beta,
c, *ldc );
}
void F77_ssyr2k(int *order, char *uplow, char *transp, int *n, int *k,
float *alpha, float *a, int *lda, float *b, int *ldb,
float *beta, float *c, int *ldc ) {
int i,j,LDA,LDB,LDC;
float *A, *B, *C;
enum CBLAS_UPLO uplo;
enum CBLAS_TRANSPOSE trans;
get_uplo_type(uplow,&uplo);
get_transpose_type(transp,&trans);
if (*order == TEST_ROW_MJR) {
if (trans == CblasNoTrans) {
LDA = *k+1;
LDB = *k+1;
A = ( float* )malloc( (*n)*LDA*sizeof( float ) );
B = ( float* )malloc( (*n)*LDB*sizeof( float ) );
for( i=0; i<*n; i++ )
for( j=0; j<*k; j++ ) {
A[i*LDA+j]=a[j*(*lda)+i];
B[i*LDB+j]=b[j*(*ldb)+i];
}
}
else {
LDA = *n+1;
LDB = *n+1;
A = ( float* )malloc( LDA*(*k)*sizeof( float ) );
B = ( float* )malloc( LDB*(*k)*sizeof( float ) );
for( i=0; i<*k; i++ )
for( j=0; j<*n; j++ ){
A[i*LDA+j]=a[j*(*lda)+i];
B[i*LDB+j]=b[j*(*ldb)+i];
}
}
LDC = *n+1;
C = ( float* )malloc( (*n)*LDC*sizeof( float ) );
for( i=0; i<*n; i++ )
for( j=0; j<*n; j++ )
C[i*LDC+j]=c[j*(*ldc)+i];
cblas_ssyr2k(CblasRowMajor, uplo, trans, *n, *k, *alpha, A, LDA,
B, LDB, *beta, C, LDC );
for( j=0; j<*n; j++ )
for( i=0; i<*n; i++ )
c[j*(*ldc)+i]=C[i*LDC+j];
free(A);
free(B);
free(C);
}
else if (*order == TEST_COL_MJR)
cblas_ssyr2k(CblasColMajor, uplo, trans, *n, *k, *alpha, a, *lda,
b, *ldb, *beta, c, *ldc );
else
cblas_ssyr2k(UNDEFINED, uplo, trans, *n, *k, *alpha, a, *lda,
b, *ldb, *beta, c, *ldc );
}
void F77_ctpsv(int *order, char *uplow, char *transp, char *diagn,
int *n, CBLAS_TEST_COMPLEX *ap, CBLAS_TEST_COMPLEX *x, int *incx) {
CBLAS_TEST_COMPLEX *A, *AP;
int i, j, k, LDA;
enum CBLAS_TRANSPOSE trans;
enum CBLAS_UPLO uplo;
enum CBLAS_DIAG diag;
get_transpose_type(transp,&trans);
get_uplo_type(uplow,&uplo);
get_diag_type(diagn,&diag);
if (*order == TEST_ROW_MJR) {
if (uplo != CblasUpper && uplo != CblasLower )
cblas_ctpsv( CblasRowMajor, UNDEFINED, trans, diag, *n, ap, x, *incx );
else {
LDA = *n;
A=(CBLAS_TEST_COMPLEX*)malloc(LDA*LDA*sizeof(CBLAS_TEST_COMPLEX));
AP=(CBLAS_TEST_COMPLEX*)malloc((((LDA+1)*LDA)/2)*
sizeof(CBLAS_TEST_COMPLEX));
if (uplo == CblasUpper) {
for( j=0, k=0; j<*n; j++ )
for( i=0; i<j+1; i++, k++ ) {
A[ LDA*i+j ].real=ap[ k ].real;
A[ LDA*i+j ].imag=ap[ k ].imag;
}
for( i=0, k=0; i<*n; i++ )
for( j=i; j<*n; j++, k++ ) {
AP[ k ].real=A[ LDA*i+j ].real;
AP[ k ].imag=A[ LDA*i+j ].imag;
}
}
else {
for( j=0, k=0; j<*n; j++ )
for( i=j; i<*n; i++, k++ ) {
A[ LDA*i+j ].real=ap[ k ].real;
A[ LDA*i+j ].imag=ap[ k ].imag;
}
for( i=0, k=0; i<*n; i++ )
for( j=0; j<i+1; j++, k++ ) {
AP[ k ].real=A[ LDA*i+j ].real;
AP[ k ].imag=A[ LDA*i+j ].imag;
}
}
cblas_ctpsv( CblasRowMajor, uplo, trans, diag, *n, AP, x, *incx );
free(A);
free(AP);
}
}
else if (*order == TEST_COL_MJR)
cblas_ctpsv( CblasColMajor, uplo, trans, diag, *n, ap, x, *incx );
else
cblas_ctpsv( UNDEFINED, uplo, trans, diag, *n, ap, x, *incx );
}
void F77_strsm(int *order, char *rtlf, char *uplow, char *transp, char *diagn,
int *m, int *n, float *alpha, float *a, int *lda, float *b,
int *ldb) {
int i,j,LDA,LDB;
float *A, *B;
enum CBLAS_SIDE side;
enum CBLAS_DIAG diag;
enum CBLAS_UPLO uplo;
enum CBLAS_TRANSPOSE trans;
get_uplo_type(uplow,&uplo);
get_transpose_type(transp,&trans);
get_diag_type(diagn,&diag);
get_side_type(rtlf,&side);
if (*order == TEST_ROW_MJR) {
if (side == CblasLeft) {
LDA = *m+1;
A = ( float* )malloc( (*m)*LDA*sizeof( float ) );
for( i=0; i<*m; i++ )
for( j=0; j<*m; j++ )
A[i*LDA+j]=a[j*(*lda)+i];
}
else{
LDA = *n+1;
A = ( float* )malloc( (*n)*LDA*sizeof( float ) );
for( i=0; i<*n; i++ )
for( j=0; j<*n; j++ )
A[i*LDA+j]=a[j*(*lda)+i];
}
LDB = *n+1;
B = ( float* )malloc( (*m)*LDB*sizeof( float ) );
for( i=0; i<*m; i++ )
for( j=0; j<*n; j++ )
B[i*LDB+j]=b[j*(*ldb)+i];
cblas_strsm(CblasRowMajor, side, uplo, trans, diag, *m, *n, *alpha,
A, LDA, B, LDB );
for( j=0; j<*n; j++ )
for( i=0; i<*m; i++ )
b[j*(*ldb)+i]=B[i*LDB+j];
free(A);
free(B);
}
else if (*order == TEST_COL_MJR)
cblas_strsm(CblasColMajor, side, uplo, trans, diag, *m, *n, *alpha,
a, *lda, b, *ldb);
else
cblas_strsm(UNDEFINED, side, uplo, trans, diag, *m, *n, *alpha,
a, *lda, b, *ldb);
}
void F77_cgbmv(int *order, char *transp, int *m, int *n, int *kl, int *ku,
CBLAS_TEST_COMPLEX *alpha, CBLAS_TEST_COMPLEX *a, int *lda,
CBLAS_TEST_COMPLEX *x, int *incx,
CBLAS_TEST_COMPLEX *beta, CBLAS_TEST_COMPLEX *y, int *incy) {
CBLAS_TEST_COMPLEX *A;
int i,j,irow,jcol,LDA;
enum CBLAS_TRANSPOSE trans;
get_transpose_type(transp, &trans);
if (*order == TEST_ROW_MJR) {
LDA = *ku+*kl+2;
A=( CBLAS_TEST_COMPLEX* )malloc((*n+*kl)*LDA*sizeof(CBLAS_TEST_COMPLEX));
for( i=0; i<*ku; i++ ){
irow=*ku+*kl-i;
jcol=(*ku)-i;
for( j=jcol; j<*n; j++ ){
A[ LDA*(j-jcol)+irow ].real=a[ (*lda)*j+i ].real;
A[ LDA*(j-jcol)+irow ].imag=a[ (*lda)*j+i ].imag;
}
}
i=*ku;
irow=*ku+*kl-i;
for( j=0; j<*n; j++ ){
A[ LDA*j+irow ].real=a[ (*lda)*j+i ].real;
A[ LDA*j+irow ].imag=a[ (*lda)*j+i ].imag;
}
for( i=*ku+1; i<*ku+*kl+1; i++ ){
irow=*ku+*kl-i;
jcol=i-(*ku);
for( j=jcol; j<(*n+*kl); j++ ){
A[ LDA*j+irow ].real=a[ (*lda)*(j-jcol)+i ].real;
A[ LDA*j+irow ].imag=a[ (*lda)*(j-jcol)+i ].imag;
}
}
cblas_cgbmv( CblasRowMajor, trans, *m, *n, *kl, *ku, alpha, A, LDA, x,
*incx, beta, y, *incy );
free(A);
}
else if (*order == TEST_COL_MJR)
cblas_cgbmv( CblasColMajor, trans, *m, *n, *kl, *ku, alpha, a, *lda, x,
*incx, beta, y, *incy );
else
cblas_cgbmv( UNDEFINED, trans, *m, *n, *kl, *ku, alpha, a, *lda, x,
*incx, beta, y, *incy );
}
void F77_stbsv(int *order, char *uplow, char *transp, char *diagn,
int *n, int *k, float *a, int *lda, float *x, int *incx) {
float *A;
int irow, jcol, i, j, LDA;
enum CBLAS_TRANSPOSE trans;
enum CBLAS_UPLO uplo;
enum CBLAS_DIAG diag;
get_transpose_type(transp,&trans);
get_uplo_type(uplow,&uplo);
get_diag_type(diagn,&diag);
if (*order == TEST_ROW_MJR) {
LDA = *k+1;
A = ( float* )malloc( (*n+*k)*LDA*sizeof( float ) );
if (uplo == CblasUpper) {
for( i=0; i<*k; i++ ){
irow=*k-i;
jcol=(*k)-i;
for( j=jcol; j<*n; j++ )
A[ LDA*(j-jcol)+irow ]=a[ (*lda)*j+i ];
}
i=*k;
irow=*k-i;
for( j=0; j<*n; j++ )
A[ LDA*j+irow ]=a[ (*lda)*j+i ];
}
else {
i=0;
irow=*k-i;
for( j=0; j<*n; j++ )
A[ LDA*j+irow ]=a[ (*lda)*j+i ];
for( i=1; i<*k+1; i++ ){
irow=*k-i;
jcol=i;
for( j=jcol; j<(*n+*k); j++ )
A[ LDA*j+irow ]=a[ (*lda)*(j-jcol)+i ];
}
}
cblas_stbsv(CblasRowMajor, uplo, trans, diag, *n, *k, A, LDA, x, *incx);
free(A);
}
else
cblas_stbsv(CblasColMajor, uplo, trans, diag, *n, *k, a, *lda, x, *incx);
}
void F77_dtpsv(int *order, char *uplow, char *transp, char *diagn,
int *n, double *ap, double *x, int *incx) {
double *A, *AP;
int i, j, k, LDA;
enum CBLAS_TRANSPOSE trans;
enum CBLAS_UPLO uplo;
enum CBLAS_DIAG diag;
get_transpose_type(transp,&trans);
get_uplo_type(uplow,&uplo);
get_diag_type(diagn,&diag);
if (*order == TEST_ROW_MJR) {
LDA = *n;
A = ( double* )malloc( LDA*LDA*sizeof( double ) );
AP = ( double* )malloc( (((LDA+1)*LDA)/2)*sizeof( double ) );
if (uplo == CblasUpper) {
for( j=0, k=0; j<*n; j++ )
for( i=0; i<j+1; i++, k++ )
A[ LDA*i+j ]=ap[ k ];
for( i=0, k=0; i<*n; i++ )
for( j=i; j<*n; j++, k++ )
AP[ k ]=A[ LDA*i+j ];
}
else {
for( j=0, k=0; j<*n; j++ )
for( i=j; i<*n; i++, k++ )
A[ LDA*i+j ]=ap[ k ];
for( i=0, k=0; i<*n; i++ )
for( j=0; j<i+1; j++, k++ )
AP[ k ]=A[ LDA*i+j ];
}
cblas_dtpsv( CblasRowMajor, uplo, trans, diag, *n, AP, x, *incx );
free(A);
free(AP);
}
else
cblas_dtpsv( CblasColMajor, uplo, trans, diag, *n, ap, x, *incx );
}
void F77_sgbmv(int *order, char *transp, int *m, int *n, int *kl, int *ku,
float *alpha, float *a, int *lda, float *x, int *incx,
float *beta, float *y, int *incy ) {
float *A;
int i,irow,j,jcol,LDA;
enum CBLAS_TRANSPOSE trans;
get_transpose_type(transp, &trans);
if (*order == TEST_ROW_MJR) {
LDA = *ku+*kl+2;
A = ( float* )malloc( (*n+*kl)*LDA*sizeof( float ) );
for( i=0; i<*ku; i++ ){
irow=*ku+*kl-i;
jcol=(*ku)-i;
for( j=jcol; j<*n; j++ )
A[ LDA*(j-jcol)+irow ]=a[ (*lda)*j+i ];
}
i=*ku;
irow=*ku+*kl-i;
for( j=0; j<*n; j++ )
A[ LDA*j+irow ]=a[ (*lda)*j+i ];
for( i=*ku+1; i<*ku+*kl+1; i++ ){
irow=*ku+*kl-i;
jcol=i-(*ku);
for( j=jcol; j<(*n+*kl); j++ )
A[ LDA*j+irow ]=a[ (*lda)*(j-jcol)+i ];
}
cblas_sgbmv( CblasRowMajor, trans, *m, *n, *kl, *ku, *alpha,
A, LDA, x, *incx, *beta, y, *incy );
free(A);
}
else
cblas_sgbmv( CblasColMajor, trans, *m, *n, *kl, *ku, *alpha,
a, *lda, x, *incx, *beta, y, *incy );
}
void F77_cgemm(int *layout, char *transpa, char *transpb, int *m, int *n,
int *k, CBLAS_TEST_COMPLEX *alpha, CBLAS_TEST_COMPLEX *a, int *lda,
CBLAS_TEST_COMPLEX *b, int *ldb, CBLAS_TEST_COMPLEX *beta,
CBLAS_TEST_COMPLEX *c, int *ldc ) {
CBLAS_TEST_COMPLEX *A, *B, *C;
int i,j,LDA, LDB, LDC;
CBLAS_TRANSPOSE transa, transb;
get_transpose_type(transpa, &transa);
get_transpose_type(transpb, &transb);
if (*layout == TEST_ROW_MJR) {
if (transa == CblasNoTrans) {
LDA = *k+1;
A=(CBLAS_TEST_COMPLEX*)malloc((*m)*LDA*sizeof(CBLAS_TEST_COMPLEX));
for( i=0; i<*m; i++ )
for( j=0; j<*k; j++ ) {
A[i*LDA+j].real=a[j*(*lda)+i].real;
A[i*LDA+j].imag=a[j*(*lda)+i].imag;
}
}
else {
LDA = *m+1;
A=(CBLAS_TEST_COMPLEX* )malloc(LDA*(*k)*sizeof(CBLAS_TEST_COMPLEX));
for( i=0; i<*k; i++ )
for( j=0; j<*m; j++ ) {
A[i*LDA+j].real=a[j*(*lda)+i].real;
A[i*LDA+j].imag=a[j*(*lda)+i].imag;
}
}
if (transb == CblasNoTrans) {
LDB = *n+1;
B=(CBLAS_TEST_COMPLEX* )malloc((*k)*LDB*sizeof(CBLAS_TEST_COMPLEX) );
for( i=0; i<*k; i++ )
for( j=0; j<*n; j++ ) {
B[i*LDB+j].real=b[j*(*ldb)+i].real;
B[i*LDB+j].imag=b[j*(*ldb)+i].imag;
}
}
else {
LDB = *k+1;
B=(CBLAS_TEST_COMPLEX* )malloc(LDB*(*n)*sizeof(CBLAS_TEST_COMPLEX));
for( i=0; i<*n; i++ )
for( j=0; j<*k; j++ ) {
B[i*LDB+j].real=b[j*(*ldb)+i].real;
B[i*LDB+j].imag=b[j*(*ldb)+i].imag;
}
}
LDC = *n+1;
C=(CBLAS_TEST_COMPLEX* )malloc((*m)*LDC*sizeof(CBLAS_TEST_COMPLEX));
for( j=0; j<*n; j++ )
for( i=0; i<*m; i++ ) {
C[i*LDC+j].real=c[j*(*ldc)+i].real;
C[i*LDC+j].imag=c[j*(*ldc)+i].imag;
}
cblas_cgemm( CblasRowMajor, transa, transb, *m, *n, *k, alpha, A, LDA,
B, LDB, beta, C, LDC );
for( j=0; j<*n; j++ )
for( i=0; i<*m; i++ ) {
c[j*(*ldc)+i].real=C[i*LDC+j].real;
c[j*(*ldc)+i].imag=C[i*LDC+j].imag;
}
free(A);
free(B);
free(C);
}
else if (*layout == TEST_COL_MJR)
cblas_cgemm( CblasColMajor, transa, transb, *m, *n, *k, alpha, a, *lda,
b, *ldb, beta, c, *ldc );
else
cblas_cgemm( UNDEFINED, transa, transb, *m, *n, *k, alpha, a, *lda,
b, *ldb, beta, c, *ldc );
}
void F77_ctbsv(int *order, char *uplow, char *transp, char *diagn,
int *n, int *k, CBLAS_TEST_COMPLEX *a, int *lda, CBLAS_TEST_COMPLEX *x,
int *incx) {
CBLAS_TEST_COMPLEX *A;
int irow, jcol, i, j, LDA;
enum CBLAS_TRANSPOSE trans;
enum CBLAS_UPLO uplo;
enum CBLAS_DIAG diag;
get_transpose_type(transp,&trans);
get_uplo_type(uplow,&uplo);
get_diag_type(diagn,&diag);
if (*order == TEST_ROW_MJR) {
if (uplo != CblasUpper && uplo != CblasLower )
cblas_ctbsv(CblasRowMajor, UNDEFINED, trans, diag, *n, *k, a, *lda, x,
*incx);
else {
LDA = *k+2;
A=(CBLAS_TEST_COMPLEX*)malloc((*n+*k)*LDA*sizeof(CBLAS_TEST_COMPLEX ));
if (uplo == CblasUpper) {
for( i=0; i<*k; i++ ){
irow=*k-i;
jcol=(*k)-i;
for( j=jcol; j<*n; j++ ) {
A[ LDA*(j-jcol)+irow ].real=a[ (*lda)*j+i ].real;
A[ LDA*(j-jcol)+irow ].imag=a[ (*lda)*j+i ].imag;
}
}
i=*k;
irow=*k-i;
for( j=0; j<*n; j++ ) {
A[ LDA*j+irow ].real=a[ (*lda)*j+i ].real;
A[ LDA*j+irow ].imag=a[ (*lda)*j+i ].imag;
}
}
else {
i=0;
irow=*k-i;
for( j=0; j<*n; j++ ) {
A[ LDA*j+irow ].real=a[ (*lda)*j+i ].real;
A[ LDA*j+irow ].imag=a[ (*lda)*j+i ].imag;
}
for( i=1; i<*k+1; i++ ){
irow=*k-i;
jcol=i;
for( j=jcol; j<(*n+*k); j++ ) {
A[ LDA*j+irow ].real=a[ (*lda)*(j-jcol)+i ].real;
A[ LDA*j+irow ].imag=a[ (*lda)*(j-jcol)+i ].imag;
}
}
}
cblas_ctbsv(CblasRowMajor, uplo, trans, diag, *n, *k, A, LDA,
x, *incx);
free(A);
}
}
else if (*order == TEST_COL_MJR)
cblas_ctbsv(CblasColMajor, uplo, trans, diag, *n, *k, a, *lda, x, *incx);
else
cblas_ctbsv(UNDEFINED, uplo, trans, diag, *n, *k, a, *lda, x, *incx);
}
void F77_sgemm(int *order, char *transpa, char *transpb, int *m, int *n,
int *k, float *alpha, float *a, int *lda, float *b, int *ldb,
float *beta, float *c, int *ldc ) {
float *A, *B, *C;
int i,j,LDA, LDB, LDC;
enum CBLAS_TRANSPOSE transa, transb;
get_transpose_type(transpa, &transa);
get_transpose_type(transpb, &transb);
if (*order == TEST_ROW_MJR) {
if (transa == CblasNoTrans) {
LDA = *k+1;
A = (float *)malloc( (*m)*LDA*sizeof( float ) );
for( i=0; i<*m; i++ )
for( j=0; j<*k; j++ )
A[i*LDA+j]=a[j*(*lda)+i];
}
else {
LDA = *m+1;
A = ( float* )malloc( LDA*(*k)*sizeof( float ) );
for( i=0; i<*k; i++ )
for( j=0; j<*m; j++ )
A[i*LDA+j]=a[j*(*lda)+i];
}
if (transb == CblasNoTrans) {
LDB = *n+1;
B = ( float* )malloc( (*k)*LDB*sizeof( float ) );
for( i=0; i<*k; i++ )
for( j=0; j<*n; j++ )
B[i*LDB+j]=b[j*(*ldb)+i];
}
else {
LDB = *k+1;
B = ( float* )malloc( LDB*(*n)*sizeof( float ) );
for( i=0; i<*n; i++ )
for( j=0; j<*k; j++ )
B[i*LDB+j]=b[j*(*ldb)+i];
}
LDC = *n+1;
C = ( float* )malloc( (*m)*LDC*sizeof( float ) );
for( j=0; j<*n; j++ )
for( i=0; i<*m; i++ )
C[i*LDC+j]=c[j*(*ldc)+i];
cblas_sgemm( CblasRowMajor, transa, transb, *m, *n, *k, *alpha, A, LDA,
B, LDB, *beta, C, LDC );
for( j=0; j<*n; j++ )
for( i=0; i<*m; i++ )
c[j*(*ldc)+i]=C[i*LDC+j];
free(A);
free(B);
free(C);
}
else if (*order == TEST_COL_MJR)
cblas_sgemm( CblasColMajor, transa, transb, *m, *n, *k, *alpha, a, *lda,
b, *ldb, *beta, c, *ldc );
else
cblas_sgemm( UNDEFINED, transa, transb, *m, *n, *k, *alpha, a, *lda,
b, *ldb, *beta, c, *ldc );
}
