/* ----------------------------------------------------------------------
* Main NVector Testing Routine
* --------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
int fails = 0; /* counter for test failures */
long int local_length, global_length; /* vector lengths */
N_Vector W;
N_Vector X, Y, Z; /* test vectors */
MPI_Comm comm; /* MPI Communicator */
int nprocs, myid; /* Number of procs, proc id */
long int veclen; /* vector length */
int print_timing;
HYPRE_Int *partitioning; /* Vector Partitioning */
HYPRE_ParVector Xhyp; /* Instantiate hypre parallel vector */
/* check input and set vector length */
if (argc < 3) {
SetTiming(0);
} else {
print_timing = atoi(argv[2]);
SetTiming(print_timing);
}
if (argc < 2) {
veclen = VECLEN;
} else {
veclen = atol(argv[1]);
if (veclen <= 0) {
printf("ERROR: length of vector must be a positive integer \n");
return(-1);
}
}
/* printf("\nRunning with vector length %ld \n \n", veclen); */
/* Get processor number and total number of processes */
MPI_Init(&argc, &argv);
/* omp_set_num_threads(4); */
comm = MPI_COMM_WORLD;
MPI_Comm_size(comm, &nprocs);
MPI_Comm_rank(comm, &myid);
/* set partitioning */
local_length = veclen;
global_length = nprocs*local_length;
if(HYPRE_AssumedPartitionCheck()) {
partitioning = (HYPRE_Int*) malloc(2*sizeof(HYPRE_Int));
partitioning[0] = myid*local_length;
partitioning[1] = (myid+1)*local_length;
} else {
partitioning = (HYPRE_Int*) malloc((nprocs+1)*sizeof(HYPRE_Int));
if (veclen <= 0) {
printf("Using global partition.\n");
printf("I don't do this stuff. Now exiting...\n");
return -1;
}
}
/* Create template hypre vector */
HYPRE_ParVectorCreate(comm, global_length, partitioning, &Xhyp);
HYPRE_ParVectorInitialize(Xhyp);
/* Create empty vector */
W = N_VNewEmpty_ParHyp(comm, local_length, global_length);
/* NVector Test */
/* Hypre specific tests */
fails += Test_N_VMake(Xhyp, myid);
/* Create hypre vector wrapper */
X = N_VMake_ParHyp(Xhyp);
/* Memory allocation tests */
fails += Test_N_VCloneEmpty(X, myid);
fails += Test_N_VClone(X, local_length, myid);
fails += Test_N_VCloneEmptyVectorArray(5, X, myid);
fails += Test_N_VCloneVectorArray(5, X, local_length, myid);
/* Create a couple of more vectors by cloning X */
Y = N_VClone(X);
Z = N_VClone(X);
/* Skipped tests */
/* Accessing HYPRE vector raw data is not allowed from N_Vector interface */
/* fails += Test_N_VSetArrayPointer(W, local_length, myid); */
/* fails += Test_N_VGetArrayPointer(X, local_length, myid); */
/* N_Vector interface tests */
fails += Test_N_VGetVectorID(W, myid);
fails += Test_N_VConst(X, local_length, myid);
fails += Test_N_VLinearSum(X, Y, Z, local_length, myid);
fails += Test_N_VProd(X, Y, Z, local_length, myid);
fails += Test_N_VDiv(X, Y, Z, local_length, myid);
fails += Test_N_VScale(X, Z, local_length, myid);
fails += Test_N_VAbs(X, Z, local_length, myid);
fails += Test_N_VInv(X, Z, local_length, myid);
fails += Test_N_VAddConst(X, Z, local_length, myid);
fails += Test_N_VDotProd(X, Y, local_length, global_length, myid);
fails += Test_N_VMaxNorm(X, local_length, myid);
fails += Test_N_VWrmsNorm(X, Y, local_length, myid);
fails += Test_N_VWrmsNormMask(X, Y, Z, local_length, global_length, myid);
fails += Test_N_VMin(X, local_length, myid);
fails += Test_N_VWL2Norm(X, Y, local_length, global_length, myid);
fails += Test_N_VL1Norm(X, local_length, global_length, myid);
fails += Test_N_VCompare(X, Z, local_length, myid);
fails += Test_N_VInvTest(X, Z, local_length, myid);
fails += Test_N_VConstrMask(X, Y, Z, local_length, myid);
fails += Test_N_VMinQuotient(X, Y, local_length, myid);
/* Free vectors */
N_VDestroy_ParHyp(W);
N_VDestroy_ParHyp(X);
N_VDestroy_ParHyp(Y);
N_VDestroy_ParHyp(Z);
/* Print result */
if (fails) {
printf("FAIL: NVector module failed %i tests, Proc %d \n \n", fails, myid);
} else {
if(myid == 0) {
printf("SUCCESS: NVector module passed all tests, Proc %d \n \n",myid);
}
}
/* Free hypre template vector */
HYPRE_ParVectorDestroy(Xhyp);
MPI_Finalize();
return(0);
}
/* ----------------------------------------------------------------------
* Main SUNMatrix Testing Routine
* --------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
int fails = 0; /* counter for test failures */
sunindextype matrows, matcols; /* vector length */
N_Vector x, y; /* test vectors */
realtype *xdata, *ydata; /* pointers to vector data */
SUNMatrix A, I; /* test matrices */
realtype *Adata, *Idata; /* pointers to matrix data */
int print_timing, square;
sunindextype i, j, m, n;
/* check input and set vector length */
if (argc < 4){
printf("ERROR: THREE (3) Input required: matrix rows, matrix cols, print timing \n");
return(-1);
}
matrows = atol(argv[1]);
if (matrows <= 0) {
printf("ERROR: number of rows must be a positive integer \n");
return(-1);
}
matcols = atol(argv[2]);
if (matcols <= 0) {
printf("ERROR: number of cols must be a positive integer \n");
return(-1);
}
print_timing = atoi(argv[3]);
SetTiming(print_timing);
square = (matrows == matcols) ? 1 : 0;
printf("\nDense matrix test: size %ld by %ld\n\n",
(long int) matrows, (long int) matcols);
/* Initialize vectors and matrices to NULL */
x = NULL;
y = NULL;
A = NULL;
I = NULL;
/* Create vectors and matrices */
x = N_VNew_Serial(matcols);
y = N_VNew_Serial(matrows);
A = SUNDenseMatrix(matrows, matcols);
I = NULL;
if (square)
I = SUNDenseMatrix(matrows, matcols);
/* Fill matrices and vectors */
Adata = SUNDenseMatrix_Data(A);
for(j=0; j < matcols; j++) {
for(i=0; i < matrows; i++) {
Adata[j*matrows + i] = (j+1)*(i+j);
}
}
if (square) {
Idata = SUNDenseMatrix_Data(I);
for(i=0, j=0; i < matrows; i++, j++) {
Idata[j*matrows + i] = ONE;
}
}
xdata = N_VGetArrayPointer(x);
for(i=0; i < matcols; i++) {
xdata[i] = ONE / (i+1);
}
ydata = N_VGetArrayPointer(y);
for(i=0; i < matrows; i++) {
m = i;
n = m + matcols - 1;
ydata[i] = HALF*(n+1-m)*(n+m);
}
/* SUNMatrix Tests */
fails += Test_SUNMatGetID(A, SUNMATRIX_DENSE, 0);
fails += Test_SUNMatClone(A, 0);
fails += Test_SUNMatCopy(A, 0);
fails += Test_SUNMatZero(A, 0);
if (square) {
fails += Test_SUNMatScaleAdd(A, I, 0);
fails += Test_SUNMatScaleAddI(A, I, 0);
}
fails += Test_SUNMatMatvec(A, x, y, 0);
fails += Test_SUNMatSpace(A, 0);
/* Print result */
if (fails) {
printf("FAIL: SUNMatrix module failed %i tests \n \n", fails);
printf("\nA =\n");
SUNDenseMatrix_Print(A,stdout);
if (square) {
printf("\nI =\n");
SUNDenseMatrix_Print(I,stdout);
}
printf("\nx =\n");
N_VPrint_Serial(x);
printf("\ny =\n");
N_VPrint_Serial(y);
} else {
printf("SUCCESS: SUNMatrix module passed all tests \n \n");
}
/* Free vectors and matrices */
N_VDestroy_Serial(x);
N_VDestroy_Serial(y);
SUNMatDestroy(A);
if (square)
SUNMatDestroy(I);
return(fails);
}
/* ----------------------------------------------------------------------
* SUNLinSol_SPGMR Linear Solver Testing Routine
*
* We run multiple tests to exercise this solver:
* 1. simple tridiagonal system (no preconditioning)
* 2. simple tridiagonal system (Jacobi preconditioning)
* 3. tridiagonal system w/ scale vector s1 (no preconditioning)
* 4. tridiagonal system w/ scale vector s1 (Jacobi preconditioning)
* 5. tridiagonal system w/ scale vector s2 (no preconditioning)
* 6. tridiagonal system w/ scale vector s2 (Jacobi preconditioning)
*
* Note: We construct a tridiagonal matrix Ahat, a random solution xhat,
* and a corresponding rhs vector bhat = Ahat*xhat, such that each
* of these is unit-less. To test row/column scaling, we use the
* matrix A = S1-inverse Ahat S2, rhs vector b = S1-inverse bhat,
* and solution vector x = (S2-inverse) xhat; hence the linear
* system has rows scaled by S1-inverse and columns scaled by S2,
* where S1 and S2 are the diagonal matrices with entries from the
* vectors s1 and s2, the 'scaling' vectors supplied to SPGMR
* having strictly positive entries. When this is combined with
* preconditioning, assume that Phat is the desired preconditioner
* for Ahat, then our preconditioning matrix P \approx A should be
* left prec: P-inverse \approx S1-inverse Ahat-inverse S1
* right prec: P-inverse \approx S2-inverse Ahat-inverse S2.
* Here we use a diagonal preconditioner D, so the S*-inverse
* and S* in the product cancel one another.
* --------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
int fails=0; /* counter for test failures */
int passfail=0; /* overall pass/fail flag */
SUNLinearSolver LS; /* linear solver object */
N_Vector xhat, x, b; /* test vectors */
UserData ProbData; /* problem data structure */
int gstype, pretype, maxl, print_timing;
sunindextype i;
realtype *vecdata;
double tol;
/* check inputs: local problem size, timing flag */
if (argc < 7) {
printf("ERROR: SIX (6) Inputs required:\n");
printf(" Problem size should be >0\n");
printf(" Gram-Schmidt orthogonalization type should be 1 or 2\n");
printf(" Preconditioning type should be 1 or 2\n");
printf(" Maximum Krylov subspace dimension should be >0\n");
printf(" Solver tolerance should be >0\n");
printf(" timing output flag should be 0 or 1 \n");
return 1;
}
ProbData.N = atol(argv[1]);
problem_size = ProbData.N;
if (ProbData.N <= 0) {
printf("ERROR: Problem size must be a positive integer\n");
return 1;
}
gstype = atoi(argv[2]);
if ((gstype < 1) || (gstype > 2)) {
printf("ERROR: Gram-Schmidt orthogonalization type must be either 1 or 2\n");
return 1;
}
pretype = atoi(argv[3]);
if ((pretype < 1) || (pretype > 2)) {
printf("ERROR: Preconditioning type must be either 1 or 2\n");
return 1;
}
maxl = atoi(argv[4]);
if (maxl <= 0) {
printf("ERROR: Maximum Krylov subspace dimension must be a positive integer\n");
return 1;
}
tol = atof(argv[5]);
if (tol <= ZERO) {
printf("ERROR: Solver tolerance must be a positive real number\n");
return 1;
}
print_timing = atoi(argv[6]);
SetTiming(print_timing);
printf("\nSPGMR linear solver test:\n");
printf(" Problem size = %ld\n", (long int) ProbData.N);
printf(" Gram-Schmidt orthogonalization type = %i\n", gstype);
printf(" Preconditioning type = %i\n", pretype);
printf(" Maximum Krylov subspace dimension = %i\n", maxl);
printf(" Solver Tolerance = %"GSYM"\n", tol);
printf(" timing output flag = %i\n\n", print_timing);
/* Create vectors */
x = N_VNew_Serial(ProbData.N);
if (check_flag(x, "N_VNew_Serial", 0)) return 1;
xhat = N_VNew_Serial(ProbData.N);
if (check_flag(xhat, "N_VNew_Serial", 0)) return 1;
b = N_VNew_Serial(ProbData.N);
if (check_flag(b, "N_VNew_Serial", 0)) return 1;
ProbData.d = N_VNew_Serial(ProbData.N);
if (check_flag(ProbData.d, "N_VNew_Serial", 0)) return 1;
ProbData.s1 = N_VNew_Serial(ProbData.N);
if (check_flag(ProbData.s1, "N_VNew_Serial", 0)) return 1;
ProbData.s2 = N_VNew_Serial(ProbData.N);
if (check_flag(ProbData.s2, "N_VNew_Serial", 0)) return 1;
/* Fill xhat vector with uniform random data in [1,2] */
vecdata = N_VGetArrayPointer(xhat);
for (i=0; i<ProbData.N; i++)
vecdata[i] = ONE + urand();
/* Fill Jacobi vector with matrix diagonal */
N_VConst(FIVE, ProbData.d);
/* Create SPGMR linear solver */
LS = SUNLinSol_SPGMR(x, pretype, maxl);
fails += Test_SUNLinSolGetType(LS, SUNLINEARSOLVER_ITERATIVE, 0);
fails += Test_SUNLinSolSetATimes(LS, &ProbData, ATimes, 0);
fails += Test_SUNLinSolSetPreconditioner(LS, &ProbData, PSetup, PSolve, 0);
fails += Test_SUNLinSolSetScalingVectors(LS, ProbData.s1, ProbData.s2, 0);
fails += Test_SUNLinSolInitialize(LS, 0);
fails += Test_SUNLinSolSpace(LS, 0);
fails += SUNLinSol_SPGMRSetGSType(LS, gstype);
if (fails) {
printf("FAIL: SUNLinSol_SPGMR module failed %i initialization tests\n\n", fails);
return 1;
} else {
printf("SUCCESS: SUNLinSol_SPGMR module passed all initialization tests\n\n");
}
/*** Test 1: simple Poisson-like solve (no preconditioning) ***/
/* set scaling vectors */
N_VConst(ONE, ProbData.s1);
N_VConst(ONE, ProbData.s2);
/* Fill x vector with scaled version */
N_VDiv(xhat,ProbData.s2,x);
/* Fill b vector with result of matrix-vector product */
fails = ATimes(&ProbData, x, b);
if (check_flag(&fails, "ATimes", 1)) return 1;
/* Run tests with this setup */
fails += SUNLinSol_SPGMRSetPrecType(LS, PREC_NONE);
fails += Test_SUNLinSolSetup(LS, NULL, 0);
fails += Test_SUNLinSolSolve(LS, NULL, x, b, tol, 0);
fails += Test_SUNLinSolLastFlag(LS, 0);
fails += Test_SUNLinSolNumIters(LS, 0);
fails += Test_SUNLinSolResNorm(LS, 0);
fails += Test_SUNLinSolResid(LS, 0);
/* Print result */
if (fails) {
printf("FAIL: SUNLinSol_SPGMR module, problem 1, failed %i tests\n\n", fails);
passfail += 1;
} else {
printf("SUCCESS: SUNLinSol_SPGMR module, problem 1, passed all tests\n\n");
}
/*** Test 2: simple Poisson-like solve (Jacobi preconditioning) ***/
/* set scaling vectors */
N_VConst(ONE, ProbData.s1);
N_VConst(ONE, ProbData.s2);
/* Fill x vector with scaled version */
N_VDiv(xhat,ProbData.s2,x);
/* Fill b vector with result of matrix-vector product */
fails = ATimes(&ProbData, x, b);
if (check_flag(&fails, "ATimes", 1)) return 1;
/* Run tests with this setup */
fails += SUNLinSol_SPGMRSetPrecType(LS, pretype);
fails += Test_SUNLinSolSetup(LS, NULL, 0);
fails += Test_SUNLinSolSolve(LS, NULL, x, b, tol, 0);
fails += Test_SUNLinSolLastFlag(LS, 0);
fails += Test_SUNLinSolNumIters(LS, 0);
fails += Test_SUNLinSolResNorm(LS, 0);
fails += Test_SUNLinSolResid(LS, 0);
/* Print result */
if (fails) {
printf("FAIL: SUNLinSol_SPGMR module, problem 2, failed %i tests\n\n", fails);
passfail += 1;
} else {
printf("SUCCESS: SUNLinSol_SPGMR module, problem 2, passed all tests\n\n");
}
/*** Test 3: Poisson-like solve w/ scaled rows (no preconditioning) ***/
/* set scaling vectors */
vecdata = N_VGetArrayPointer(ProbData.s1);
for (i=0; i<ProbData.N; i++)
vecdata[i] = ONE + THOUSAND*urand();
N_VConst(ONE, ProbData.s2);
/* Fill x vector with scaled version */
N_VDiv(xhat,ProbData.s2,x);
/* Fill b vector with result of matrix-vector product */
fails = ATimes(&ProbData, x, b);
if (check_flag(&fails, "ATimes", 1)) return 1;
/* Run tests with this setup */
fails += SUNLinSol_SPGMRSetPrecType(LS, PREC_NONE);
fails += Test_SUNLinSolSetup(LS, NULL, 0);
fails += Test_SUNLinSolSolve(LS, NULL, x, b, tol, 0);
fails += Test_SUNLinSolLastFlag(LS, 0);
fails += Test_SUNLinSolNumIters(LS, 0);
fails += Test_SUNLinSolResNorm(LS, 0);
fails += Test_SUNLinSolResid(LS, 0);
/* Print result */
if (fails) {
printf("FAIL: SUNLinSol_SPGMR module, problem 3, failed %i tests\n\n", fails);
passfail += 1;
} else {
printf("SUCCESS: SUNLinSol_SPGMR module, problem 3, passed all tests\n\n");
}
/*** Test 4: Poisson-like solve w/ scaled rows (Jacobi preconditioning) ***/
/* set scaling vectors */
vecdata = N_VGetArrayPointer(ProbData.s1);
for (i=0; i<ProbData.N; i++)
vecdata[i] = ONE + THOUSAND*urand();
N_VConst(ONE, ProbData.s2);
/* Fill x vector with scaled version */
N_VDiv(xhat,ProbData.s2,x);
/* Fill b vector with result of matrix-vector product */
fails = ATimes(&ProbData, x, b);
if (check_flag(&fails, "ATimes", 1)) return 1;
/* Run tests with this setup */
fails += SUNLinSol_SPGMRSetPrecType(LS, pretype);
fails += Test_SUNLinSolSetup(LS, NULL, 0);
fails += Test_SUNLinSolSolve(LS, NULL, x, b, tol, 0);
fails += Test_SUNLinSolLastFlag(LS, 0);
fails += Test_SUNLinSolNumIters(LS, 0);
fails += Test_SUNLinSolResNorm(LS, 0);
fails += Test_SUNLinSolResid(LS, 0);
/* Print result */
if (fails) {
printf("FAIL: SUNLinSol_SPGMR module, problem 4, failed %i tests\n\n", fails);
passfail += 1;
} else {
printf("SUCCESS: SUNLinSol_SPGMR module, problem 4, passed all tests\n\n");
}
/*** Test 5: Poisson-like solve w/ scaled columns (no preconditioning) ***/
/* set scaling vectors */
N_VConst(ONE, ProbData.s1);
vecdata = N_VGetArrayPointer(ProbData.s2);
for (i=0; i<ProbData.N; i++)
vecdata[i] = ONE + THOUSAND*urand();
/* Fill x vector with scaled version */
N_VDiv(xhat,ProbData.s2,x);
/* Fill b vector with result of matrix-vector product */
fails = ATimes(&ProbData, x, b);
if (check_flag(&fails, "ATimes", 1)) return 1;
/* Run tests with this setup */
fails += SUNLinSol_SPGMRSetPrecType(LS, PREC_NONE);
fails += Test_SUNLinSolSetup(LS, NULL, 0);
fails += Test_SUNLinSolSolve(LS, NULL, x, b, tol, 0);
fails += Test_SUNLinSolLastFlag(LS, 0);
fails += Test_SUNLinSolNumIters(LS, 0);
fails += Test_SUNLinSolResNorm(LS, 0);
fails += Test_SUNLinSolResid(LS, 0);
/* Print result */
if (fails) {
printf("FAIL: SUNLinSol_SPGMR module, problem 5, failed %i tests\n\n", fails);
passfail += 1;
} else {
printf("SUCCESS: SUNLinSol_SPGMR module, problem 5, passed all tests\n\n");
}
/*** Test 6: Poisson-like solve w/ scaled columns (Jacobi preconditioning) ***/
/* set scaling vector, Jacobi solver vector */
N_VConst(ONE, ProbData.s1);
vecdata = N_VGetArrayPointer(ProbData.s2);
for (i=0; i<ProbData.N; i++)
vecdata[i] = ONE + THOUSAND*urand();
/* Fill x vector with scaled version */
N_VDiv(xhat,ProbData.s2,x);
/* Fill b vector with result of matrix-vector product */
fails = ATimes(&ProbData, x, b);
if (check_flag(&fails, "ATimes", 1)) return 1;
/* Run tests with this setup */
fails += SUNLinSol_SPGMRSetPrecType(LS, pretype);
fails += Test_SUNLinSolSetup(LS, NULL, 0);
fails += Test_SUNLinSolSolve(LS, NULL, x, b, tol, 0);
fails += Test_SUNLinSolLastFlag(LS, 0);
fails += Test_SUNLinSolNumIters(LS, 0);
fails += Test_SUNLinSolResNorm(LS, 0);
fails += Test_SUNLinSolResid(LS, 0);
/* Print result */
if (fails) {
printf("FAIL: SUNLinSol_SPGMR module, problem 6, failed %i tests\n\n", fails);
passfail += 1;
} else {
printf("SUCCESS: SUNLinSol_SPGMR module, problem 6, passed all tests\n\n");
}
/* Free solver and vectors */
SUNLinSolFree(LS);
N_VDestroy(x);
N_VDestroy(xhat);
N_VDestroy(b);
N_VDestroy(ProbData.d);
N_VDestroy(ProbData.s1);
N_VDestroy(ProbData.s2);
return(passfail);
}
/* ----------------------------------------------------------------------
* Main NVector Testing Routine
* --------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
int fails = 0; /* counter for test failures */
long int veclen; /* vector length */
N_Vector W, X, Y, Z; /* test vectors */
int num_threads;
int print_timing;
/* check input and set vector length */
if (argc < 4){
printf("ERROR: THREE (3) arguments required: <vector length> <number of threads> <print timing>\n");
return(-1);
}
veclen = atol(argv[1]);
if (veclen <= 0) {
printf("ERROR: length of vector must be a positive integer \n");
return(-1);
}
num_threads = atoi(argv[2]);
if (num_threads <= 0) {
printf("ERROR: numbber of threads must be a positive integer \n");
return(-1);
}
print_timing = atoi(argv[3]);
SetTiming(print_timing);
printf("\nRunning with vector length %ld \n \n", veclen);
printf("\nRunning with number of threads %d \n \n", num_threads);
/* Create vectors */
W = N_VNewEmpty_OpenMP(veclen, num_threads);
X = N_VNew_OpenMP(veclen, num_threads);
Y = N_VNew_OpenMP(veclen, num_threads);
Z = N_VNew_OpenMP(veclen, num_threads);
/* NVector Tests */
fails += Test_N_VSetArrayPointer(W, veclen, 0);
fails += Test_N_VGetArrayPointer(X, veclen, 0);
fails += Test_N_VLinearSum(X, Y, Z, veclen, 0);
fails += Test_N_VConst(X, veclen, 0);
fails += Test_N_VProd(X, Y, Z, veclen, 0);
fails += Test_N_VDiv(X, Y, Z, veclen, 0);
fails += Test_N_VScale(X, Z, veclen, 0);
fails += Test_N_VAbs(X, Z, veclen, 0);
fails += Test_N_VInv(X, Z, veclen, 0);
fails += Test_N_VAddConst(X, Z, veclen, 0);
fails += Test_N_VDotProd(X, Y, veclen, veclen, 0);
fails += Test_N_VMaxNorm(X, veclen, 0);
fails += Test_N_VWrmsNorm(X, Y, veclen, 0);
fails += Test_N_VWrmsNormMask(X, Y, Z, veclen, veclen, 0);
fails += Test_N_VMin(X, veclen, 0);
fails += Test_N_VWL2Norm(X, Y, veclen, veclen, 0);
fails += Test_N_VL1Norm(X, veclen, veclen, 0);
fails += Test_N_VCompare(X, Z, veclen, 0);
fails += Test_N_VInvTest(X, Z, veclen, 0);
fails += Test_N_VConstrMask(X, Y, Z, veclen, 0);
fails += Test_N_VMinQuotient(X, Y, veclen, 0);
fails += Test_N_VCloneVectorArray(5, X, veclen, 0);
fails += Test_N_VCloneEmptyVectorArray(5, X, 0);
fails += Test_N_VCloneEmpty(X, 0);
fails += Test_N_VClone(X, veclen, 0);
/* Free vectors */
N_VDestroy_OpenMP(W);
N_VDestroy_OpenMP(X);
N_VDestroy_OpenMP(Y);
N_VDestroy_OpenMP(Z);
/* Print results */
if (fails) {
printf("FAIL: NVector module failed %i tests \n \n", fails);
} else {
printf("SUCCESS: NVector module passed all tests \n \n");
}
return(0);
}
/* ----------------------------------------------------------------------
* Main SUNMatrix Testing Routine
* --------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
int fails=0; /* counter for test failures */
sunindextype matrows, matcols; /* matrix dims */
int mattype; /* matrix storage type */
N_Vector x, y, z; /* test vectors */
realtype* vecdata; /* pointers to vector data */
SUNMatrix A, B, C, D, I; /* test matrices */
realtype* matdata; /* pointer to matrix data */
sunindextype i, j, k, kstart, kend, N, uband, lband;
sunindextype *colptrs, *rowindices;
sunindextype *rowptrs, *colindices;
int print_timing, square;
/* check input and set vector length */
if (argc < 5){
printf("ERROR: FOUR (4) Input required: matrix rows, matrix cols, matrix type (0/1), print timing \n");
return(-1);
}
matrows = atol(argv[1]);
if (matrows < 1) {
printf("ERROR: number of rows must be a positive integer\n");
return(-1);
}
matcols = atol(argv[2]);
if (matcols < 1) {
printf("ERROR: number of cols must be a positive integer\n");
return(-1);
}
k = atol(argv[3]);
if ((k != 0) && (k != 1)) {
printf("ERROR: matrix type must be 0 or 1\n");
return(-1);
}
mattype = (k == 0) ? CSC_MAT : CSR_MAT;
print_timing = atoi(argv[4]);
SetTiming(print_timing);
square = (matrows == matcols) ? 1 : 0;
printf("\nSparse matrix test: size %ld by %ld, type = %i\n\n",
(long int) matrows, (long int) matcols, mattype);
/* Initialize vectors and matrices to NULL */
x = NULL;
y = NULL;
z = NULL;
A = NULL;
B = NULL;
C = NULL;
D = NULL;
I = NULL;
/* check creating sparse matrix from dense matrix */
B = SUNDenseMatrix(5,6);
matdata = SUNDenseMatrix_Data(B);
matdata[2] = RCONST(1.0); /* [ 0 2 0 0 7 0 ] */
matdata[5] = RCONST(2.0); /* [ 0 0 4 0 8 0 ] */
matdata[9] = RCONST(3.0); /* [ 1 0 0 0 0 0 ] */
matdata[11] = RCONST(4.0); /* [ 0 0 5 6 0 0 ] */
matdata[13] = RCONST(5.0); /* [ 0 3 0 0 0 9 ] */
matdata[18] = RCONST(6.0);
matdata[20] = RCONST(7.0);
matdata[21] = RCONST(8.0);
matdata[29] = RCONST(9.0);
if (mattype == CSR_MAT) {
/* Check CSR */
C = SUNSparseMatrix(5, 6, 9, CSR_MAT);
rowptrs = SUNSparseMatrix_IndexPointers(C);
colindices = SUNSparseMatrix_IndexValues(C);
matdata = SUNSparseMatrix_Data(C);
rowptrs[0] = 0;
matdata[0] = RCONST(2.0); colindices[0] = 1;
matdata[1] = RCONST(7.0); colindices[1] = 4;
rowptrs[1] = 2;
matdata[2] = RCONST(4.0); colindices[2] = 2;
matdata[3] = RCONST(8.0); colindices[3] = 4;
rowptrs[2] = 4;
matdata[4] = RCONST(1.0); colindices[4] = 0;
rowptrs[3] = 5;
matdata[5] = RCONST(5.0); colindices[5] = 2;
matdata[6] = RCONST(6.0); colindices[6] = 3;
rowptrs[4] = 7;
matdata[7] = RCONST(3.0); colindices[7] = 1;
matdata[8] = RCONST(9.0); colindices[8] = 5;
rowptrs[5] = 9;
A = SUNSparseFromDenseMatrix(B, ZERO, CSR_MAT);
fails += check_matrix(A, C, 1e-15);
if (fails) {
printf("FAIL: SUNMatrix SparseFromDense CSR conversion failed\n");
return(1);
}
SUNMatDestroy(A);
SUNMatDestroy(C);
} else {
/* Check CSC */
D = SUNSparseMatrix(5, 6, 9, CSC_MAT);
colptrs = SUNSparseMatrix_IndexPointers(D);
rowindices = SUNSparseMatrix_IndexValues(D);
matdata = SUNSparseMatrix_Data(D);
colptrs[0] = 0;
matdata[0] = RCONST(1.0); rowindices[0] = 2;
colptrs[1] = 1;
matdata[1] = RCONST(2.0); rowindices[1] = 0;
matdata[2] = RCONST(3.0); rowindices[2] = 4;
colptrs[2] = 3;
matdata[3] = RCONST(4.0); rowindices[3] = 1;
matdata[4] = RCONST(5.0); rowindices[4] = 3;
colptrs[3] = 5;
matdata[5] = RCONST(6.0); rowindices[5] = 3;
colptrs[4] = 6;
matdata[6] = RCONST(7.0); rowindices[6] = 0;
matdata[7] = RCONST(8.0); rowindices[7] = 1;
colptrs[5] = 8;
matdata[8] = RCONST(9.0); rowindices[8] = 4;
colptrs[6] = 9;
A = SUNSparseFromDenseMatrix(B, 1e-15, CSC_MAT);
fails += check_matrix(A, D, 1e-15);
if (fails) {
printf("FAIL: SUNMatrix SparseFromDense CSC conversion failed\n");
return(1);
}
SUNMatDestroy(A);
SUNMatDestroy(D);
}
SUNMatDestroy(B);
/* check creating sparse matrix from banded matrix */
N = 7;
uband = 1;
lband = 2; /* B(i,j) = j + (j-i) */
B = SUNBandMatrix(N, uband, lband); /* B = [ 0 2 0 0 0 0 0 ] */
for (j=0; j<N; j++) { /* [ -1 1 3 0 0 0 0 ] */
matdata = SUNBandMatrix_Column(B, j); /* [ -2 0 2 4 0 0 0 ] */
kstart = (j<uband) ? -j : -uband; /* [ 0 -1 1 3 5 0 0 ] */
kend = (j>N-1-lband) ? N-1-j: lband; /* [ 0 0 0 2 4 6 0 ] */
for (k=kstart; k<=kend; k++) /* [ 0 0 0 1 3 5 7 ] */
matdata[k] = j - k; /* [ 0 0 0 0 2 4 6 ] */
}
if (mattype == CSR_MAT) {
/* CSR */
C = SUNSparseMatrix(7, 7, 21, CSR_MAT);
rowptrs = SUNSparseMatrix_IndexPointers(C);
colindices = SUNSparseMatrix_IndexValues(C);
matdata = SUNSparseMatrix_Data(C);
rowptrs[ 0] = 0;
matdata[ 0] = RCONST(2.0); colindices[ 0] = 1;
rowptrs[ 1] = 1;
matdata[ 1] = RCONST(-1.0); colindices[ 1] = 0;
matdata[ 2] = RCONST(1.0); colindices[ 2] = 1;
matdata[ 3] = RCONST(3.0); colindices[ 3] = 2;
rowptrs[ 2] = 4;
matdata[ 4] = RCONST(-2.0); colindices[ 4] = 0;
matdata[ 5] = RCONST(2.0); colindices[ 5] = 2;
matdata[ 6] = RCONST(4.0); colindices[ 6] = 3;
rowptrs[ 3] = 7;
matdata[ 7] = RCONST(-1.0); colindices[ 7] = 1;
matdata[ 8] = RCONST(1.0); colindices[ 8] = 2;
matdata[ 9] = RCONST(3.0); colindices[ 9] = 3;
matdata[10] = RCONST(5.0); colindices[10] = 4;
rowptrs[ 4] = 11;
matdata[11] = RCONST(2.0); colindices[11] = 3;
matdata[12] = RCONST(4.0); colindices[12] = 4;
matdata[13] = RCONST(6.0); colindices[13] = 5;
rowptrs[ 5] = 14;
matdata[14] = RCONST(1.0); colindices[14] = 3;
matdata[15] = RCONST(3.0); colindices[15] = 4;
matdata[16] = RCONST(5.0); colindices[16] = 5;
matdata[17] = RCONST(7.0); colindices[17] = 6;
rowptrs[ 6] = 18;
matdata[18] = RCONST(2.0); colindices[18] = 4;
matdata[19] = RCONST(4.0); colindices[19] = 5;
matdata[20] = RCONST(6.0); colindices[20] = 6;
rowptrs[ 7] = 21;
A = SUNSparseFromBandMatrix(B, ZERO, CSR_MAT);
fails += check_matrix(A, C, 1e-15);
if (fails) {
printf("FAIL: SUNMatrix SparseFromBand CSR conversion failed\n");
return(1);
}
SUNMatDestroy(A);
SUNMatDestroy(C);
} else {
/* Check CSC */
D = SUNSparseMatrix(7, 7, 21, CSC_MAT);
colptrs = SUNSparseMatrix_IndexPointers(D);
rowindices = SUNSparseMatrix_IndexValues(D);
matdata = SUNSparseMatrix_Data(D);
colptrs[ 0] = 0;
matdata[ 0] = RCONST(-1.0); rowindices[ 0] = 1;
matdata[ 1] = RCONST(-2.0); rowindices[ 1] = 2;
colptrs[ 1] = 2;
matdata[ 2] = RCONST(2.0); rowindices[ 2] = 0;
matdata[ 3] = RCONST(1.0); rowindices[ 3] = 1;
matdata[ 4] = RCONST(-1.0); rowindices[ 4] = 3;
colptrs[ 2] = 5;
matdata[ 5] = RCONST(3.0); rowindices[ 5] = 1;
matdata[ 6] = RCONST(2.0); rowindices[ 6] = 2;
matdata[ 7] = RCONST(1.0); rowindices[ 7] = 3;
colptrs[ 3] = 8;
matdata[ 8] = RCONST(4.0); rowindices[ 8] = 2;
matdata[ 9] = RCONST(3.0); rowindices[ 9] = 3;
matdata[10] = RCONST(2.0); rowindices[10] = 4;
matdata[11] = RCONST(1.0); rowindices[11] = 5;
colptrs[ 4] = 12;
matdata[12] = RCONST(5.0); rowindices[12] = 3;
matdata[13] = RCONST(4.0); rowindices[13] = 4;
matdata[14] = RCONST(3.0); rowindices[14] = 5;
matdata[15] = RCONST(2.0); rowindices[15] = 6;
colptrs[ 5] = 16;
matdata[16] = RCONST(6.0); rowindices[16] = 4;
matdata[17] = RCONST(5.0); rowindices[17] = 5;
matdata[18] = RCONST(4.0); rowindices[18] = 6;
colptrs[ 6] = 19;
matdata[19] = RCONST(7.0); rowindices[19] = 5;
matdata[20] = RCONST(6.0); rowindices[20] = 6;
colptrs[ 7] = 21;
A = SUNSparseFromBandMatrix(B, 1e-15, CSC_MAT);
fails += check_matrix(A, D, 1e-15);
if (fails) {
printf("FAIL: SUNMatrix SparseFromBand CSC conversion failed\n");
return(1);
}
SUNMatDestroy(A);
SUNMatDestroy(D);
}
SUNMatDestroy(B);
/* Create/fill I matrix */
I = NULL;
if (square) {
I = SUNSparseMatrix(matrows, matcols, matcols, mattype);
matdata = SUNSparseMatrix_Data(I);
colindices = SUNSparseMatrix_IndexValues(I);
rowptrs = SUNSparseMatrix_IndexPointers(I);
for(i=0; i<matrows; i++) {
matdata[i] = ONE;
colindices[i] = i;
rowptrs[i] = i;
}
rowptrs[matrows] = matrows;
}
/* Create/fill random dense matrices, create sparse from them */
C = SUNDenseMatrix(matrows, matcols);
D = SUNDenseMatrix(matrows, matcols);
for (k=0; k<3*matrows; k++) {
i = rand() % matrows;
j = rand() % matcols;
matdata = SUNDenseMatrix_Column(D,j);
matdata[i] = (realtype) rand() / (realtype) RAND_MAX;
}
for (k=0; k<matrows; k++) {
i = rand() % matrows;
j = rand() % matcols;
matdata = SUNDenseMatrix_Column(C,j);
matdata[i] = (realtype) rand() / (realtype) RAND_MAX;
}
A = SUNSparseFromDenseMatrix(C, ZERO, mattype);
B = SUNSparseFromDenseMatrix(D, ZERO, mattype);
/* Create vectors and fill */
x = N_VNew_Serial(matcols);
y = N_VNew_Serial(matrows);
z = N_VNew_Serial(matrows);
vecdata = N_VGetArrayPointer(x);
for(i=0; i<matcols; i++)
vecdata[i] = (realtype) rand() / (realtype) RAND_MAX;
if (SUNMatMatvec(C, x, y) != 0) {
printf("FAIL: SUNMatrix module Dense matvec failure \n \n");
SUNMatDestroy(A); SUNMatDestroy(B);
SUNMatDestroy(C); SUNMatDestroy(D);
N_VDestroy(x); N_VDestroy(y); N_VDestroy(z);
if (square)
SUNMatDestroy(I);
return(1);
}
if (SUNMatMatvec(D, x, z) != 0) {
printf("FAIL: SUNMatrix module Dense matvec failure \n \n");
SUNMatDestroy(A); SUNMatDestroy(B);
SUNMatDestroy(C); SUNMatDestroy(D);
N_VDestroy(x); N_VDestroy(y); N_VDestroy(z);
if (square)
SUNMatDestroy(I);
return(1);
}
/* SUNMatrix Tests */
fails += Test_SUNMatGetID(A, SUNMATRIX_SPARSE, 0);
fails += Test_SUNMatClone(A, 0);
fails += Test_SUNMatCopy(A, 0);
fails += Test_SUNMatZero(A, 0);
fails += Test_SUNMatScaleAdd(A, I, 0);
fails += Test_SUNMatScaleAdd2(A, B, x, y, z);
if (square) {
fails += Test_SUNMatScaleAddI(A, I, 0);
fails += Test_SUNMatScaleAddI2(A, x, y);
}
fails += Test_SUNMatMatvec(A, x, y, 0);
fails += Test_SUNMatSpace(A, 0);
/* Print result */
if (fails) {
printf("FAIL: SUNMatrix module failed %i tests \n \n", fails);
printf("\nA =\n");
SUNSparseMatrix_Print(A,stdout);
printf("\nB =\n");
SUNSparseMatrix_Print(B,stdout);
if (square) {
printf("\nI =\n");
SUNSparseMatrix_Print(I,stdout);
}
printf("\nx =\n");
N_VPrint_Serial(x);
printf("\ny =\n");
N_VPrint_Serial(y);
printf("\nz =\n");
N_VPrint_Serial(z);
} else {
printf("SUCCESS: SUNMatrix module passed all tests \n \n");
}
/* Free vectors and matrices */
N_VDestroy(x);
N_VDestroy(y);
N_VDestroy(z);
SUNMatDestroy(A);
SUNMatDestroy(B);
SUNMatDestroy(C);
SUNMatDestroy(D);
if (square)
SUNMatDestroy(I);
return(fails);
}
/* ----------------------------------------------------------------------
* SUNLinSol_Dense Testing Routine
* --------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
int fails = 0; /* counter for test failures */
sunindextype cols, rows; /* matrix columns, rows */
SUNLinearSolver LS; /* solver object */
SUNMatrix A, B, I; /* test matrices */
N_Vector x, y, b; /* test vectors */
int print_timing;
sunindextype j, k;
realtype *colj, *xdata, *colIj;
/* check input and set matrix dimensions */
if (argc < 3){
printf("ERROR: TWO (2) Inputs required: matrix cols, print timing \n");
return(-1);
}
cols = atol(argv[1]);
if (cols <= 0) {
printf("ERROR: number of matrix columns must be a positive integer \n");
return(-1);
}
rows = cols;
print_timing = atoi(argv[2]);
SetTiming(print_timing);
printf("\nDense linear solver test: size %ld\n\n",
(long int) cols);
/* Create matrices and vectors */
A = SUNDenseMatrix(rows, cols);
B = SUNDenseMatrix(rows, cols);
I = SUNDenseMatrix(rows, cols);
x = N_VNew_Serial(cols);
y = N_VNew_Serial(cols);
b = N_VNew_Serial(cols);
/* Fill A matrix with uniform random data in [0,1/cols] */
for (j=0; j<cols; j++) {
colj = SUNDenseMatrix_Column(A, j);
for (k=0; k<rows; k++)
colj[k] = (realtype) rand() / (realtype) RAND_MAX / cols;
}
/* Create anti-identity matrix */
j=cols-1;
for (k=0; k<rows; k++) {
colj = SUNDenseMatrix_Column(I,j);
colj[k] = 1;
j = j-1;
}
/* Add anti-identity to ensure the solver needs to do row-swapping */
for (k=0; k<rows; k++){
for(j=0; j<cols; j++){
colj = SUNDenseMatrix_Column(A,j);
colIj = SUNDenseMatrix_Column(I,j);
colj[k] = colj[k] + colIj[k];
}
}
/* Fill x vector with uniform random data in [0,1] */
xdata = N_VGetArrayPointer(x);
for (j=0; j<cols; j++) {
xdata[j] = (realtype) rand() / (realtype) RAND_MAX;
}
/* copy A and x into B and y to print in case of solver failure */
SUNMatCopy(A, B);
N_VScale(ONE, x, y);
/* create right-hand side vector for linear solve */
fails = SUNMatMatvec(A, x, b);
if (fails) {
printf("FAIL: SUNLinSol SUNMatMatvec failure\n");
/* Free matrices and vectors */
SUNMatDestroy(A);
SUNMatDestroy(B);
SUNMatDestroy(I);
N_VDestroy(x);
N_VDestroy(y);
N_VDestroy(b);
return(1);
}
/* Create dense linear solver */
LS = SUNLinSol_Dense(x, A);
/* Run Tests */
fails += Test_SUNLinSolInitialize(LS, 0);
fails += Test_SUNLinSolSetup(LS, A, 0);
fails += Test_SUNLinSolSolve(LS, A, x, b, 10*UNIT_ROUNDOFF, 0);
fails += Test_SUNLinSolGetType(LS, SUNLINEARSOLVER_DIRECT, 0);
fails += Test_SUNLinSolLastFlag(LS, 0);
fails += Test_SUNLinSolSpace(LS, 0);
/* Print result */
if (fails) {
printf("FAIL: SUNLinSol module failed %i tests \n \n", fails);
printf("\nA (original) =\n");
SUNDenseMatrix_Print(B,stdout);
printf("\nA (factored) =\n");
SUNDenseMatrix_Print(A,stdout);
printf("\nx (original) =\n");
N_VPrint_Serial(y);
printf("\nx (computed) =\n");
N_VPrint_Serial(x);
} else {
printf("SUCCESS: SUNLinSol module passed all tests \n \n");
}
/* Free solver, matrix and vectors */
SUNLinSolFree(LS);
SUNMatDestroy(A);
SUNMatDestroy(B);
SUNMatDestroy(I);
N_VDestroy(x);
N_VDestroy(y);
N_VDestroy(b);
return(fails);
}
