int check_matrix_entry(SUNMatrix A, realtype val, realtype tol)
{
int failure = 0;
realtype *Adata;
sunindextype Aldata;
sunindextype i;
/* get data pointer */
Adata = SUNDenseMatrix_Data(A);
/* compare data */
Aldata = SUNDenseMatrix_LData(A);
for(i=0; i < Aldata; i++){
failure += FNEQ(Adata[i], val, tol);
}
if (failure > ZERO) {
printf("Check_matrix_entry failures:\n");
for(i=0; i < Aldata; i++)
if (FNEQ(Adata[i], val, tol) != 0)
printf(" Adata[%ld] = %g != %g (err = %g)\n", (long int) i,
Adata[i], val, SUNRabs(Adata[i]-val));
}
if (failure > ZERO)
return(1);
else
return(0);
}
int check_vector(N_Vector x, N_Vector y, realtype tol)
{
int failure = 0;
realtype *xdata, *ydata;
sunindextype xldata, yldata;
sunindextype i;
/* get vector data */
xdata = N_VGetArrayPointer(x);
ydata = N_VGetArrayPointer(y);
/* check data lengths */
xldata = N_VGetLength_Serial(x);
yldata = N_VGetLength_Serial(y);
if (xldata != yldata) {
printf(">>> ERROR: check_vector: Different data array lengths \n");
return(1);
}
/* check vector data */
for(i=0; i < xldata; i++){
failure += FNEQ(xdata[i], ydata[i], tol);
}
if (failure > ZERO)
return(1);
else
return(0);
}
/* ----------------------------------------------------------------------
* Check matrix
* --------------------------------------------------------------------*/
int check_matrix(SUNMatrix A, SUNMatrix B, realtype tol)
{
int failure = 0;
realtype *Adata, *Bdata;
sunindextype Aldata, Bldata;
sunindextype i;
/* get data pointers */
Adata = SUNDenseMatrix_Data(A);
Bdata = SUNDenseMatrix_Data(B);
/* get and check data lengths */
Aldata = SUNDenseMatrix_LData(A);
Bldata = SUNDenseMatrix_LData(B);
if (Aldata != Bldata) {
printf(">>> ERROR: check_matrix: Different data array lengths \n");
return(1);
}
/* compare data */
for(i=0; i < Aldata; i++){
failure += FNEQ(Adata[i], Bdata[i], tol);
}
if (failure > ZERO)
return(1);
else
return(0);
}
/* ----------------------------------------------------------------------
* Implementation-specific 'check' routines
* --------------------------------------------------------------------*/
int check_vector(N_Vector X, N_Vector Y, realtype tol)
{
int failure = 0;
sunindextype i, local_length;
realtype *Xdata, *Ydata, maxerr;
Xdata = N_VGetArrayPointer(X);
Ydata = N_VGetArrayPointer(Y);
local_length = N_VGetLength_Serial(X);
/* check vector data */
for(i=0; i < local_length; i++)
failure += FNEQ(Xdata[i], Ydata[i], tol);
if (failure > ZERO) {
maxerr = ZERO;
for(i=0; i < local_length; i++)
maxerr = SUNMAX(SUNRabs(Xdata[i]-Ydata[i]), maxerr);
printf("check err failure: maxerr = %g (tol = %g)\n",
maxerr, tol);
return(1);
}
else
return(0);
}
int check_vector(N_Vector x, N_Vector y, realtype tol)
{
int failure = 0;
realtype *xdata, *ydata;
sunindextype xldata, yldata;
sunindextype i;
/* get vector data */
xdata = N_VGetArrayPointer(x);
ydata = N_VGetArrayPointer(y);
/* check data lengths */
xldata = N_VGetLength_Serial(x);
yldata = N_VGetLength_Serial(y);
if (xldata != yldata) {
printf(">>> ERROR: check_vector: Different data array lengths \n");
return(1);
}
/* check vector data */
for(i=0; i < xldata; i++)
failure += FNEQ(xdata[i], ydata[i], tol);
if (failure > ZERO) {
printf("Check_vector failures:\n");
for(i=0; i < xldata; i++)
if (FNEQ(xdata[i], ydata[i], tol) != 0)
printf(" xdata[%ld] = %g != %g (err = %g)\n", (long int) i,
xdata[i], ydata[i], SUNRabs(xdata[i]-ydata[i]));
}
if (failure > ZERO)
return(1);
else
return(0);
}
/* ----------------------------------------------------------------------
* Check vector
*
* Checks if all elements of vector X are set to value ans.
* --------------------------------------------------------------------*/
int check_ans(realtype ans, N_Vector X, long int local_length)
{
int failure = 0;
long int i;
hypre_ParVector *Xvec = N_VGetVector_ParHyp(X);
realtype *Xdata = Xvec == NULL ? NULL : hypre_VectorData(hypre_ParVectorLocalVector(Xvec));
/* check vector data */
for(i=0; i < local_length; i++) {
failure += FNEQ(Xdata[i], ans);
}
if (failure > ZERO)
return(1);
else
return(0);
}
/* ----------------------------------------------------------------------
* Check vector
* --------------------------------------------------------------------*/
int check_ans(realtype ans, N_Vector X, long int local_length)
{
int failure = 0;
long int i;
realtype *Xdata;
Xdata = N_VGetArrayPointer(X);
/* check vector data */
for(i=0; i < local_length; i++){
failure += FNEQ(Xdata[i], ans);
}
if (failure > ZERO)
return(1);
else
return(0);
}
int check_matrix_entry(SUNMatrix A, realtype val, realtype tol)
{
int failure = 0;
realtype *Adata;
sunindextype *indexptrs;
sunindextype i, NP;
/* get data pointer */
Adata = SUNSparseMatrix_Data(A);
/* compare data */
indexptrs = SUNSparseMatrix_IndexPointers(A);
NP = SUNSparseMatrix_NP(A);
for(i=0; i < indexptrs[NP]; i++){
failure += FNEQ(Adata[i], val, tol);
}
if (failure > ZERO)
return(1);
else
return(0);
}
/* ----------------------------------------------------------------------
* Implementation-specific 'check' routines
* --------------------------------------------------------------------*/
int check_vector(N_Vector X, N_Vector Y, realtype tol)
{
int failure = 0;
sunindextype i;
realtype *Xdata, *Ydata, maxerr;
Xdata = N_VGetArrayPointer(X);
Ydata = N_VGetArrayPointer(Y);
/* check vector data */
for(i=0; i<problem_size; i++)
failure += FNEQ(Xdata[i], Ydata[i], FIVE*tol*SUNRabs(Xdata[i]));
if (failure > ZERO) {
maxerr = ZERO;
for(i=0; i < problem_size; i++)
maxerr = SUNMAX(SUNRabs(Xdata[i]-Ydata[i])/SUNRabs(Xdata[i]), maxerr);
printf("check err failure: maxerr = %g (tol = %g)\n",
maxerr, FIVE*tol);
return(1);
}
else
return(0);
}
/* ----------------------------------------------------------------------
* Check matrix
* --------------------------------------------------------------------*/
int check_matrix(SUNMatrix A, SUNMatrix B, realtype tol)
{
int failure = 0;
realtype *Adata, *Bdata;
sunindextype *Aindexptrs, *Bindexptrs;
sunindextype *Aindexvals, *Bindexvals;
sunindextype i, ANP, BNP, Annz, Bnnz;
/* get matrix pointers */
Adata = SUNSparseMatrix_Data(A);
Aindexptrs = SUNSparseMatrix_IndexPointers(A);
Aindexvals = SUNSparseMatrix_IndexValues(A);
ANP = SUNSparseMatrix_NP(A);
Annz = Aindexptrs[ANP];
Bdata = SUNSparseMatrix_Data(B);
Bindexptrs = SUNSparseMatrix_IndexPointers(B);
Bindexvals = SUNSparseMatrix_IndexValues(B);
BNP = SUNSparseMatrix_NP(B);
Bnnz = Bindexptrs[BNP];
/* matrices must have same sparsetype, shape and actual data lengths */
if (SUNMatGetID(A) != SUNMatGetID(B)) {
printf(">>> ERROR: check_matrix: Different storage types (%d vs %d)\n",
SUNMatGetID(A), SUNMatGetID(B));
return(1);
}
if (SUNSparseMatrix_SparseType(A) != SUNSparseMatrix_SparseType(B)) {
printf(">>> ERROR: check_matrix: Different storage types (%d vs %d)\n",
SUNSparseMatrix_SparseType(A), SUNSparseMatrix_SparseType(B));
return(1);
}
if (SUNSparseMatrix_Rows(A) != SUNSparseMatrix_Rows(B)) {
printf(">>> ERROR: check_matrix: Different numbers of rows (%ld vs %ld)\n",
(long int) SUNSparseMatrix_Rows(A), (long int) SUNSparseMatrix_Rows(B));
return(1);
}
if (SUNSparseMatrix_Columns(A) != SUNSparseMatrix_Columns(B)) {
printf(">>> ERROR: check_matrix: Different numbers of columns (%ld vs %ld)\n",
(long int) SUNSparseMatrix_Columns(A),
(long int) SUNSparseMatrix_Columns(B));
return(1);
}
if (Annz != Bnnz) {
printf(">>> ERROR: check_matrix: Different numbers of nonzeos (%ld vs %ld)\n",
(long int) Annz, (long int) Bnnz);
return(1);
}
/* compare sparsity patterns */
for (i=0; i<ANP; i++)
failure += (Aindexptrs[i] != Bindexptrs[i]);
if (failure > ZERO) {
printf(">>> ERROR: check_matrix: Different indexptrs \n");
return(1);
}
for (i=0; i<Annz; i++)
failure += (Aindexvals[i] != Bindexvals[i]);
if (failure > ZERO) {
printf(">>> ERROR: check_matrix: Different indexvals \n");
return(1);
}
/* compare matrix values */
for(i=0; i<Annz; i++)
failure += FNEQ(Adata[i], Bdata[i], tol);
if (failure > ZERO) {
printf(">>> ERROR: check_matrix: Different entries \n");
return(1);
}
return(0);
}