int main () { int cores = 2; int N = 10 ; int LDA = 10 ; int info; int info_factorization; int i,j; int NminusOne = N-1; PLASMA_Complex32_t *A1 = (PLASMA_Complex32_t *)malloc(LDA*N*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *A2 = (PLASMA_Complex32_t *)malloc(LDA*N*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *WORK = (PLASMA_Complex32_t *)malloc(2*LDA*sizeof(PLASMA_Complex32_t)); float *D = (float *)malloc(LDA*sizeof(float)); /* Check if unable to allocate memory */ if ((!A1)||(!A2)){ printf("Out of Memory \n "); exit(0); } /* Plasma Initialize */ PLASMA_Init(cores); printf("-- PLASMA is initialized to run on %d cores. \n",cores); /* Initialize A1 and A2 for Symmetric Positive Matrix */ LAPACKE_slarnv_work(IONE, ISEED, LDA, D); claghe(&N, &NminusOne, D, A1, &LDA, ISEED, WORK, &info); 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]+ (PLASMA_Complex32_t)N ; A2[LDA*i+i] = A1[LDA*i+i]; } /* Plasma routines */ PLASMA_cpotrf(PlasmaUpper, N, A2, LDA); /* Check the factorization */ info_factorization = check_factorization( N, A1, A2, LDA, PlasmaUpper); if ((info_factorization != 0)|(info != 0)) printf("-- Error in CPOTRF example ! \n"); else printf("-- Run of CPOTRF example successful ! \n"); free(A1); free(A2); free(WORK); free(D); PLASMA_Finalize(); exit(0); }
int main () { int cores = 2; int N = 10 ; int LDA = 10 ; int NRHS = 5 ; int LDB = 10 ; int info; int info_solution; int i,j; int NminusOne = N-1; int LDBxNRHS = LDB*NRHS; PLASMA_Complex32_t *A1 = (PLASMA_Complex32_t *)malloc(LDA*N*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *A2 = (PLASMA_Complex32_t *)malloc(LDA*N*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *B1 = (PLASMA_Complex32_t *)malloc(LDB*NRHS*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *B2 = (PLASMA_Complex32_t *)malloc(LDB*NRHS*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *WORK = (PLASMA_Complex32_t *)malloc(2*LDA*sizeof(PLASMA_Complex32_t)); float *D = (float *)malloc(LDA*sizeof(float)); /* Check if unable to allocate memory */ if ((!A1)||(!A2)||(!B1)||(!B2)) { printf("Out of Memory \n "); exit(0); } /* Plasma Initialize */ PLASMA_Init(cores); printf("-- PLASMA is initialized to run on %d cores. \n",cores); /* Initialize A1 and A2 for Symmetric Positive Matrix */ LAPACKE_slarnv_work(IONE, ISEED, LDA, D); claghe(&N, &NminusOne, D, A1, &LDA, ISEED, WORK, &info); 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]+ (PLASMA_Complex32_t)N ; A2[LDA*i+i] = A1[LDA*i+i]; } /* Initialize B1 and B2 */ LAPACKE_clarnv_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]; /* PLASMA routines */ info = PLASMA_cpotrf(PlasmaLower, N, A2, LDA); info = PLASMA_ctrsm(PlasmaLeft, PlasmaLower, PlasmaNoTrans, PlasmaNonUnit, N, NRHS, (PLASMA_Complex32_t)1.0, A2, LDA, B2, LDB); info = PLASMA_ctrsm(PlasmaLeft, PlasmaLower, PlasmaConjTrans, PlasmaNonUnit, N, NRHS, (PLASMA_Complex32_t)1.0, A2, LDA, B2, LDB); /* Check the solution */ info_solution = check_solution(N, NRHS, A1, LDA, B1, B2, LDB); if ((info_solution != 0)|(info != 0)) printf("-- Error in CTRSM example ! \n"); else printf("-- Run of CTRSM example successful ! \n"); free(A1); free(A2); free(B1); free(B2); free(WORK); free(D); PLASMA_Finalize(); exit(0); }
int testing_cher2k(int argc, char **argv) { /* Check for number of arguments*/ if ( argc != 7 ){ USAGE("HER2K", "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; } PLASMA_Complex32_t alpha = (PLASMA_Complex32_t) atol(argv[0]); float beta = (float) 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; float eps; int info_solution; int info, u, t; size_t LDAxK = LDA*NKmax; size_t LDBxK = LDB*NKmax; size_t LDCxN = LDC*N; PLASMA_Complex32_t *A = (PLASMA_Complex32_t *)malloc(LDAxK*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *B = (PLASMA_Complex32_t *)malloc(LDBxK*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *C = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *Cinit = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *Cfinal = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *WORK = (PLASMA_Complex32_t *)malloc(2*LDC*sizeof(PLASMA_Complex32_t)); float *D = (float *) malloc(LDC *sizeof(float)); /* Check if unable to allocate memory */ if ( (!A) || (!B) || (!Cinit) || (!Cfinal) || (!D) ){ printf("Out of Memory \n "); return -2; } eps = LAPACKE_slamch_work('e'); printf("\n"); printf("------ TESTS FOR PLASMA CHER2K 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 CHER2K */ /* Initialize A,B */ LAPACKE_clarnv_work(IONE, ISEED, LDAxK, A); LAPACKE_clarnv_work(IONE, ISEED, LDBxK, B); /* Initialize C */ LAPACKE_slarnv_work(IONE, ISEED, LDC, D); claghe(&N, &NminusOne, D, C, &LDC, ISEED, WORK, &info); free(D); free(WORK); for (u=0; u<2; u++) { for (t=0; t<3; t++) { if (trans[t] == PlasmaTrans) continue; memcpy(Cinit, C, LDCxN*sizeof(PLASMA_Complex32_t)); memcpy(Cfinal, C, LDCxN*sizeof(PLASMA_Complex32_t)); /* PLASMA CHER2K */ PLASMA_cher2k(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 CHER2K (%5s, %s) ........... PASSED !\n", uplostr[u], transstr[t]); printf("***************************************************\n"); } else { printf("************************************************\n"); printf(" - TESTING CHER2K (%5s, %s) ... FAILED !\n", uplostr[u], transstr[t]); printf("************************************************\n"); } } } free(A); free(B); free(C); free(Cinit); free(Cfinal); return 0; }
int testing_csymm(int argc, char **argv) { /* Check for number of arguments*/ if ( argc != 7 ){ USAGE("SYMM", "alpha beta M N K LDA LDB LDC", " - alpha : alpha coefficient \n" " - beta : beta coefficient \n" " - M : number of rows of matrices A and C \n" " - N : number of columns of matrices B and C \n" " - LDA : leading dimension of matrix A \n" " - LDB : leading dimension of matrix B \n" " - LDC : leading dimension of matrix C\n"); return -1; } PLASMA_Complex32_t alpha = (PLASMA_Complex32_t) atol(argv[0]); PLASMA_Complex32_t beta = (PLASMA_Complex32_t) atol(argv[1]); int M = atoi(argv[2]); int N = atoi(argv[3]); int LDA = atoi(argv[4]); int LDB = atoi(argv[5]); int LDC = atoi(argv[6]); int MNmax = max(M, N); int MminusOne = MNmax - 1; float eps; int info_solution; int i, j, s, u, info; int LDAxM = LDA*max(M, N); int LDBxN = LDB*N; int LDCxN = LDC*N; PLASMA_Complex32_t *A = (PLASMA_Complex32_t *)malloc(LDAxM*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *B = (PLASMA_Complex32_t *)malloc(LDBxN*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *C = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *Cinit = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *Cfinal = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t)); PLASMA_Complex32_t *WORK = (PLASMA_Complex32_t *)malloc(2*LDC*sizeof(PLASMA_Complex32_t)); float *D = (float *) malloc(LDC *sizeof(float)); /* Check if unable to allocate memory */ if ((!A)||(!B)||(!Cinit)||(!Cfinal)){ printf("Out of Memory \n "); return -2; } eps = LAPACKE_slamch_work('e'); printf("\n"); printf("------ TESTS FOR PLASMA CSYMM ROUTINE ------- \n"); printf(" Size of the Matrix %d by %d\n", M, 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 10.\n"); /*---------------------------------------------------------- * TESTING CSYMM */ /* Initialize A */ LAPACKE_slarnv_work(IONE, ISEED, LDC, D); claghe(&MNmax, &MminusOne, D, A, &LDA, ISEED, WORK, &info); free(D); free(WORK); /* Initialize B */ LAPACKE_clarnv_work(IONE, ISEED, LDBxN, B); /* Initialize C */ LAPACKE_clarnv_work(IONE, ISEED, LDCxN, C); for (s=0; s<2; s++) { for (u=0; u<2; u++) { /* Initialize Cinit / Cfinal */ for ( i = 0; i < M; i++) for ( j = 0; j < N; j++) Cinit[LDC*j+i] = C[LDC*j+i]; for ( i = 0; i < M; i++) for ( j = 0; j < N; j++) Cfinal[LDC*j+i] = C[LDC*j+i]; /* PLASMA CSYMM */ PLASMA_csymm(side[s], uplo[u], M, N, alpha, A, LDA, B, LDB, beta, Cfinal, LDC); /* Check the solution */ info_solution = check_solution(side[s], uplo[u], M, N, alpha, A, LDA, B, LDB, beta, Cinit, Cfinal, LDC); if (info_solution == 0) { printf("***************************************************\n"); printf(" ---- TESTING CSYMM (%5s, %5s) ....... PASSED !\n", sidestr[s], uplostr[u]); printf("***************************************************\n"); } else { printf("************************************************\n"); printf(" - TESTING CSYMM (%s, %s) ... FAILED !\n", sidestr[s], uplostr[u]); printf("************************************************\n"); } } } free(A); free(B); free(C); free(Cinit); free(Cfinal); return 0; }