static booleantype SMCompatible2_Band(SUNMatrix A, N_Vector x, N_Vector y)
{
/* matrix must be SUNMATRIX_BAND */
if (SUNMatGetID(A) != SUNMATRIX_BAND)
return SUNFALSE;
/* vectors must be one of {SERIAL, OPENMP, PTHREADS} */
if ( (N_VGetVectorID(x) != SUNDIALS_NVEC_SERIAL) &&
(N_VGetVectorID(x) != SUNDIALS_NVEC_OPENMP) &&
(N_VGetVectorID(x) != SUNDIALS_NVEC_PTHREADS) )
return SUNFALSE;
/* Optimally we would verify that the dimensions of A, x and y agree,
but since there is no generic 'length' routine for N_Vectors we cannot */
return SUNTRUE;
}
/* ----------------------------------------------------------------------
* N_VGetVectorID Test
*
* --------------------------------------------------------------------*/
int Test_N_VGetVectorID(N_Vector v, int myid)
{
N_Vector_ID id = N_VGetVectorID(v);
if (id == SUNDIALS_NVEC_PARHYP) {
if (myid == 0) {
printf(" PASSED test -- N_VGetVectorID \n");
/* PRINT_TIME(" N_VMake Time: %22.15e \n \n", stop_time - start_time); */
}
return (0);
} else {
printf(">>> FAILED test -- N_VGetVectorID, Proc %d \n", myid);
printf(" Unrecognized vector type %d \n \n", id);
return (1);
}
}
SUNLinearSolver SUNLinSol_LapackDense(N_Vector y, SUNMatrix A)
{
SUNLinearSolver S;
SUNLinearSolver_Ops ops;
SUNLinearSolverContent_LapackDense content;
sunindextype MatrixRows, VecLength;
/* Check compatibility with supplied SUNMatrix and N_Vector */
if (SUNMatGetID(A) != SUNMATRIX_DENSE)
return(NULL);
if (SUNDenseMatrix_Rows(A) != SUNDenseMatrix_Columns(A))
return(NULL);
MatrixRows = SUNDenseMatrix_Rows(A);
if ( (N_VGetVectorID(y) != SUNDIALS_NVEC_SERIAL) &&
(N_VGetVectorID(y) != SUNDIALS_NVEC_OPENMP) &&
(N_VGetVectorID(y) != SUNDIALS_NVEC_PTHREADS) )
return(NULL);
/* optimally this function would be replaced with a generic N_Vector routine */
VecLength = GlobalVectorLength_LapDense(y);
if (MatrixRows != VecLength)
return(NULL);
/* Create linear solver */
S = NULL;
S = (SUNLinearSolver) malloc(sizeof *S);
if (S == NULL) return(NULL);
/* Create linear solver operation structure */
ops = NULL;
ops = (SUNLinearSolver_Ops) malloc(sizeof(struct _generic_SUNLinearSolver_Ops));
if (ops == NULL) { free(S); return(NULL); }
/* Attach operations */
ops->gettype = SUNLinSolGetType_LapackDense;
ops->initialize = SUNLinSolInitialize_LapackDense;
ops->setup = SUNLinSolSetup_LapackDense;
ops->solve = SUNLinSolSolve_LapackDense;
ops->lastflag = SUNLinSolLastFlag_LapackDense;
ops->space = SUNLinSolSpace_LapackDense;
ops->free = SUNLinSolFree_LapackDense;
ops->setatimes = NULL;
ops->setpreconditioner = NULL;
ops->setscalingvectors = NULL;
ops->numiters = NULL;
ops->resnorm = NULL;
ops->resid = NULL;
/* Create content */
content = NULL;
content = (SUNLinearSolverContent_LapackDense)
malloc(sizeof(struct _SUNLinearSolverContent_LapackDense));
if (content == NULL) { free(ops); free(S); return(NULL); }
/* Fill content */
content->N = MatrixRows;
content->last_flag = 0;
content->pivots = NULL;
content->pivots = (sunindextype *) malloc(MatrixRows * sizeof(sunindextype));
if (content->pivots == NULL) {
free(content); free(ops); free(S); return(NULL);
}
/* Attach content and ops */
S->content = content;
S->ops = ops;
return(S);
}
/* ----------------------------------------------------------------------
* 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);
if(N_VGetVectorID(W) == SUNDIALS_NVEC_OPENMP) {
/*printf("Testing OpenMP variant of N_Vector...\n");*/
}
/* 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);
}