int testing_dsyr2k(int argc, char **argv)
{
/* Check for number of arguments*/
if ( argc != 7 ){
USAGE("SYR2K", "alpha beta M N LDA LDB LDC",
" - alpha : alpha coefficient\n"
" - beta : beta coefficient\n"
" - N : number of columns and rows of matrix C and number of row of matrix A and B\n"
" - K : number of columns of matrix A and B\n"
" - LDA : leading dimension of matrix A\n"
" - LDB : leading dimension of matrix B\n"
" - LDC : leading dimension of matrix C\n");
return -1;
}
double alpha = (double) atol(argv[0]);
double beta = (double) atol(argv[1]);
int N = atoi(argv[2]);
int K = atoi(argv[3]);
int LDA = atoi(argv[4]);
int LDB = atoi(argv[5]);
int LDC = atoi(argv[6]);
int NKmax = max(N, K);
int NminusOne = N - 1;
double eps;
int info_solution;
int info, u, t;
size_t LDAxK = LDA*NKmax;
size_t LDBxK = LDB*NKmax;
size_t LDCxN = LDC*N;
double *A = (double *)malloc(LDAxK*sizeof(double));
double *B = (double *)malloc(LDBxK*sizeof(double));
double *C = (double *)malloc(LDCxN*sizeof(double));
double *Cinit = (double *)malloc(LDCxN*sizeof(double));
double *Cfinal = (double *)malloc(LDCxN*sizeof(double));
double *WORK = (double *)malloc(2*LDC*sizeof(double));
double *D = (double *) malloc(LDC *sizeof(double));
/* Check if unable to allocate memory */
if ( (!A) || (!B) || (!Cinit) || (!Cfinal) || (!D) ){
printf("Out of Memory \n ");
return -2;
}
eps = LAPACKE_dlamch_work('e');
printf("\n");
printf("------ TESTS FOR PLASMA DSYR2K ROUTINE ------- \n");
printf(" Size of the Matrix C %d by %d\n", N, K);
printf("\n");
printf(" The matrix A is randomly generated for each test.\n");
printf("============\n");
printf(" The relative machine precision (eps) is to be %e \n",eps);
printf(" Computational tests pass if scaled residuals are less than 10.\n");
/*----------------------------------------------------------
* TESTING DSYR2K
*/
/* Initialize A,B */
LAPACKE_dlarnv_work(IONE, ISEED, LDAxK, A);
LAPACKE_dlarnv_work(IONE, ISEED, LDBxK, B);
/* Initialize C */
LAPACKE_dlarnv_work(IONE, ISEED, LDC, D);
dlagsy(&N, &NminusOne, D, C, &LDC, ISEED, WORK, &info);
free(D); free(WORK);
for (u=0; u<2; u++) {
for (t=0; t<2; t++) {
memcpy(Cinit, C, LDCxN*sizeof(double));
memcpy(Cfinal, C, LDCxN*sizeof(double));
/* PLASMA DSYR2K */
PLASMA_dsyr2k(uplo[u], trans[t], N, K, alpha, A, LDA, B, LDB, beta, Cfinal, LDC);
/* Check the solution */
info_solution = check_solution(uplo[u], trans[t], N, K,
alpha, A, LDA, B, LDB, beta, Cinit, Cfinal, LDC);
if (info_solution == 0) {
printf("***************************************************\n");
printf(" ---- TESTING DSYR2K (%5s, %s) ........... PASSED !\n", uplostr[u], transstr[t]);
printf("***************************************************\n");
}
else {
printf("************************************************\n");
printf(" - TESTING DSYR2K (%5s, %s) ... FAILED !\n", uplostr[u], transstr[t]);
printf("************************************************\n");
}
}
}
free(A); free(B); free(C);
free(Cinit); free(Cfinal);
return 0;
}
int testing_dsposv(int argc, char **argv)
{
/* Check for number of arguments*/
if (argc != 4){
USAGE("CPOSV", "N LDA NRHS LDB",
" - N : the size of the matrix\n"
" - LDA : leading dimension of the matrix A\n"
" - NRHS : number of RHS\n"
" - LDB : leading dimension of the RHS B\n");
return -1;
}
int N = atoi(argv[0]);
int LDA = atoi(argv[1]);
int NRHS = atoi(argv[2]);
int LDB = atoi(argv[3]);
int ITER;
double eps;
int uplo;
int info;
int info_solution = 0; /*, info_factorization;*/
int i,j;
int NminusOne = N-1;
int LDBxNRHS = LDB*NRHS;
double *A1 = (double *)malloc(LDA*N *sizeof(double));
double *A2 = (double *)malloc(LDA*N *sizeof(double));
double *B1 = (double *)malloc(LDB*NRHS*sizeof(double));
double *B2 = (double *)malloc(LDB*NRHS*sizeof(double));
double *WORK = (double *)malloc(2*LDA *sizeof(double));
double *D = (double *)malloc(LDA*sizeof(double));
/* Check if unable to allocate memory */
if ( (!A1) || (!A2) || (!B1) || (!B2) ){
printf("Out of Memory \n ");
exit(0);
}
eps = LAPACKE_dlamch_work('e');
/*-------------------------------------------------------------
* TESTING DSPOSV
*/
/* Initialize A1 and A2 for Symmetric Positif Matrix (Hessenberg in the complex case) */
LAPACKE_dlarnv_work(IONE, ISEED, LDA, D);
dlagsy(&N, &NminusOne, D, A1, &LDA, ISEED, WORK, &info);
free(D);
for ( i = 0; i < N; i++)
for ( j = 0; j < N; j++)
A2[LDA*j+i] = A1[LDA*j+i];
for ( i = 0; i < N; i++){
A1[LDA*i+i] = A1[LDA*i+i] + N ;
A2[LDA*i+i] = A1[LDA*i+i];
}
/* Initialize B1 and B2 */
LAPACKE_dlarnv_work(IONE, ISEED, LDBxNRHS, B1);
for ( i = 0; i < N; i++)
for ( j = 0; j < NRHS; j++)
B2[LDB*j+i] = B1[LDB*j+i];
printf("\n");
printf("------ TESTS FOR PLASMA DSPOSV ROUTINE ------ \n");
printf(" Size of the Matrix %d by %d\n", N, N);
printf("\n");
printf(" The matrix A is randomly generated for each test.\n");
printf("============\n");
printf(" The relative machine precision (eps) is to be %e \n", eps);
printf(" Computational tests pass if scaled residuals are less than 60.\n");
/* PLASMA DSPOSV */
uplo = PlasmaLower;
info = PLASMA_dsposv(uplo, N, NRHS, A2, LDA, B1, LDB, B2, LDB, &ITER);
if (info != PLASMA_SUCCESS ) {
printf("PLASMA_dsposv is not completed: info = %d\n", info);
info_solution = 1;
} else {
printf(" Solution obtained with %d iterations\n", ITER);
/* Check the factorization and the solution */
info_solution = check_solution(N, NRHS, A1, LDA, B1, B2, LDB, eps);
}
if (info_solution == 0){
printf("***************************************************\n");
printf(" ---- TESTING DSPOSV ..................... PASSED !\n");
printf("***************************************************\n");
}
else{
printf("***************************************************\n");
printf(" - TESTING DSPOSV .. FAILED !\n");
printf("***************************************************\n");
}
free(A1); free(A2); free(B1); free(B2); free(WORK);
return 0;
}
