void N_VPrint_NrnThread(N_Vector x)
{
int i;
int nt;
nt = NV_NT_NT(x);
for (i=0; i < nt; i++) {
N_VPrint_Serial(NV_SUBVEC_NT(x, i));
}
printf("\n");
}
static int cpNewtonIterationExpl(CPodeMem cp_mem)
{
int m, retval;
realtype del, delp, dcon;
N_Vector b;
mnewt = m = 0;
/* Initialize delp to avoid compiler warning message */
del = delp = ZERO;
/* Looping point for Newton iteration */
loop {
#ifdef CPODES_DEBUG
printf(" Iteration # %d\n",m);
#endif
#ifdef CPODES_DEBUG_SERIAL
printf(" zn[0] = "); N_VPrint_Serial(zn[0]);
printf(" zn[1] = "); N_VPrint_Serial(zn[1]);
printf(" ewt = "); N_VPrint_Serial(ewt);
printf(" acor = "); N_VPrint_Serial(acor);
printf(" ftemp = "); N_VPrint_Serial(ftemp);
#endif
/* Evaluate the residual of the nonlinear system*/
N_VLinearSum(rl1, zn[1], ONE, acor, tempv);
N_VLinearSum(gamma, ftemp, -ONE, tempv, tempv);
/* Call the lsolve function */
b = tempv;
#ifdef CPODES_DEBUG
printf(" Linear solver solve\n");
#endif
#ifdef CPODES_DEBUG_SERIAL
printf(" rhs = "); N_VPrint_Serial(b);
#endif
retval = lsolve(cp_mem, b, ewt, y, NULL, ftemp);
#ifdef CPODES_DEBUG_SERIAL
printf(" sol = "); N_VPrint_Serial(b);
#endif
#ifdef CPODES_DEBUG
printf(" Linear solver solve return value = %d\n",retval);
#endif
nni++;
if (retval < 0) return(CP_LSOLVE_FAIL);
if (retval > 0) return(CONV_FAIL);
/* Get WRMS norm of correction; add correction to acor and y */
del = N_VWrmsNorm(b, ewt);
#ifdef CPODES_DEBUG
printf(" Norm of correction: del = %lg\n", del);
#endif
N_VLinearSum(ONE, acor, ONE, b, acor);
N_VLinearSum(ONE, zn[0], ONE, acor, y);
/* Test for convergence. If m > 0, an estimate of the convergence
rate constant is stored in crate, and used in the test. */
if (m > 0) {
crate = MAX(NLS_CRDOWN * crate, del/delp);
}
dcon = del * MIN(ONE, crate) / tq[4];
#ifdef CPODES_DEBUG
printf(" Convergence test dcon = %lg\n", dcon);
#endif
if (dcon <= ONE) {
acnrm = (m==0) ? del : N_VWrmsNorm(acor, ewt);
#ifdef CPODES_DEBUG_SERIAL
printf(" acor = "); N_VPrint_Serial(acor);
#endif
#ifdef CPODES_DEBUG
printf(" Accumulated correction norm = %lg\n", acnrm);
#endif
jcur = FALSE;
return(CP_SUCCESS); /* Nonlinear system was solved successfully */
}
mnewt = ++m;
/* Stop at maxcor iterations or if iter. seems to be diverging. */
if ((m == maxcor) || ((m >= 2) && (del > NLS_RDIV*delp))) return(CONV_FAIL);
/* Save norm of correction, evaluate f, and loop again */
delp = del;
retval = fe(tn, y, ftemp, f_data);
nfe++;
if (retval < 0) return(CP_ODEFUNC_FAIL);
if (retval > 0) return(ODEFUNC_RECVR);
} /* end loop */
}
/* ----------------------------------------------------------------------
* 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);
}
/* ----------------------------------------------------------------------
* Extra ScaleAddI tests for sparse matrices:
* A should not contain values on the diagonal, nor should it contain
* sufficient storage to add those in
* y should already equal A*x
* --------------------------------------------------------------------*/
int Test_SUNMatScaleAddI2(SUNMatrix A, N_Vector x, N_Vector y)
{
int failure;
SUNMatrix B, C, D;
N_Vector w, z;
realtype tol=100*UNIT_ROUNDOFF;
/* create clones for test */
B = SUNMatClone(A);
z = N_VClone(x);
w = N_VClone(x);
/* test 1: add I to a matrix with insufficient storage */
failure = SUNMatCopy(A, B);
if (failure) {
printf(">>> FAILED test -- SUNMatCopy returned %d \n",
failure);
SUNMatDestroy(B); N_VDestroy(z); N_VDestroy(w); return(1);
}
failure = SUNMatScaleAddI(NEG_ONE, B); /* B = I-A */
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAddI returned %d \n",
failure);
SUNMatDestroy(B); N_VDestroy(z); N_VDestroy(w); return(1);
}
failure = SUNMatMatvec(B, x, z);
if (failure) {
printf(">>> FAILED test -- SUNMatMatvec returned %d \n",
failure);
SUNMatDestroy(B); N_VDestroy(z); N_VDestroy(w); return(1);
}
N_VLinearSum(ONE,x,NEG_ONE,y,w);
failure = check_vector(z, w, tol);
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAddI2 check 1 \n");
printf("\nA =\n");
SUNSparseMatrix_Print(A,stdout);
printf("\nB =\n");
SUNSparseMatrix_Print(B,stdout);
printf("\nz =\n");
N_VPrint_Serial(z);
printf("\nw =\n");
N_VPrint_Serial(w);
SUNMatDestroy(B); N_VDestroy(z); N_VDestroy(w); return(1);
}
else {
printf(" PASSED test -- SUNMatScaleAddI2 check 1 \n");
}
/* test 2: add I to a matrix with sufficient but misplaced
storage */
C = SUNMatClone(A);
failure = SUNSparseMatrix_Reallocate(C, SM_NNZ_S(A)+SM_ROWS_S(A));
failure = SUNMatCopy(A, C);
if (failure) {
printf(">>> FAILED test -- SUNMatCopy returned %d \n",
failure);
SUNMatDestroy(B); SUNMatDestroy(C);
N_VDestroy(z); N_VDestroy(w); return(1);
}
failure = SUNMatScaleAddI(NEG_ONE, C); /* C = I-A */
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAddI returned %d \n",
failure);
SUNMatDestroy(B); SUNMatDestroy(C);
N_VDestroy(z); N_VDestroy(w); return(1);
}
failure = SUNMatMatvec(C, x, z);
if (failure) {
printf(">>> FAILED test -- SUNMatMatvec returned %d \n",
failure);
SUNMatDestroy(B); SUNMatDestroy(C);
N_VDestroy(z); N_VDestroy(w); return(1);
}
N_VLinearSum(ONE,x,NEG_ONE,y,w);
failure = check_vector(z, w, tol);
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAddI2 check 2 \n");
printf("\nA =\n");
SUNSparseMatrix_Print(A,stdout);
printf("\nC =\n");
SUNSparseMatrix_Print(C,stdout);
printf("\nz =\n");
N_VPrint_Serial(z);
printf("\nw =\n");
N_VPrint_Serial(w);
SUNMatDestroy(B); SUNMatDestroy(C);
N_VDestroy(z); N_VDestroy(w); return(1);
}
else {
printf(" PASSED test -- SUNMatScaleAddI2 check 2 \n");
}
/* test 3: add I to a matrix with appropriate structure already in place */
D = SUNMatClone(C);
failure = SUNMatCopy(C, D);
if (failure) {
printf(">>> FAILED test -- SUNMatCopy returned %d \n",
failure);
SUNMatDestroy(B); SUNMatDestroy(C); SUNMatDestroy(D);
N_VDestroy(z); N_VDestroy(w); return(1);
}
failure = SUNMatScaleAddI(NEG_ONE, D); /* D = A */
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAddI returned %d \n",
failure);
SUNMatDestroy(B); SUNMatDestroy(C); SUNMatDestroy(D);
N_VDestroy(z); N_VDestroy(w); return(1);
}
failure = SUNMatMatvec(D, x, z);
if (failure) {
printf(">>> FAILED test -- SUNMatMatvec returned %d \n",
failure);
SUNMatDestroy(B); SUNMatDestroy(C); SUNMatDestroy(D);
N_VDestroy(z); N_VDestroy(w); return(1);
}
failure = check_vector(z, y, tol);
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAddI2 check 3 \n");
printf("\nA =\n");
SUNSparseMatrix_Print(A,stdout);
printf("\nD =\n");
SUNSparseMatrix_Print(D,stdout);
printf("\nz =\n");
N_VPrint_Serial(z);
printf("\ny =\n");
N_VPrint_Serial(y);
SUNMatDestroy(B); SUNMatDestroy(C); SUNMatDestroy(D);
N_VDestroy(z); N_VDestroy(w); return(1);
}
else {
printf(" PASSED test -- SUNMatScaleAddI2 check 3 \n");
}
SUNMatDestroy(B);
SUNMatDestroy(C);
SUNMatDestroy(D);
N_VDestroy(z);
N_VDestroy(w);
return(0);
}
/* ----------------------------------------------------------------------
* Extra ScaleAdd tests for sparse matrices:
* A and B should have different sparsity patterns, and neither should
* contain sufficient storage to for their sum
* y should already equal A*x
* z should already equal B*x
* --------------------------------------------------------------------*/
int Test_SUNMatScaleAdd2(SUNMatrix A, SUNMatrix B, N_Vector x,
N_Vector y, N_Vector z)
{
int failure;
SUNMatrix C, D, E;
N_Vector u, v;
realtype tol=100*UNIT_ROUNDOFF;
/* create clones for test */
C = SUNMatClone(A);
u = N_VClone(y);
v = N_VClone(y);
/* test 1: add A to B (output must be enlarged) */
failure = SUNMatCopy(A, C); /* C = A */
if (failure) {
printf(">>> FAILED test -- SUNMatCopy returned %d \n",
failure);
SUNMatDestroy(C); N_VDestroy(u); N_VDestroy(v); return(1);
}
failure = SUNMatScaleAdd(ONE, C, B); /* C = A+B */
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAdd returned %d \n",
failure);
SUNMatDestroy(C); N_VDestroy(u); N_VDestroy(v); return(1);
}
failure = SUNMatMatvec(C, x, u); /* u = Cx = Ax+Bx */
if (failure) {
printf(">>> FAILED test -- SUNMatMatvec returned %d \n",
failure);
SUNMatDestroy(C); N_VDestroy(u); N_VDestroy(v); return(1);
}
N_VLinearSum(ONE,y,ONE,z,v); /* v = y+z */
failure = check_vector(u, v, tol); /* u ?= v */
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAdd2 check 1 \n");
printf("\nA =\n");
SUNSparseMatrix_Print(A,stdout);
printf("\nB =\n");
SUNSparseMatrix_Print(B,stdout);
printf("\nC =\n");
SUNSparseMatrix_Print(C,stdout);
printf("\nx =\n");
N_VPrint_Serial(x);
printf("\ny =\n");
N_VPrint_Serial(y);
printf("\nz =\n");
N_VPrint_Serial(z);
printf("\nu =\n");
N_VPrint_Serial(u);
printf("\nv =\n");
N_VPrint_Serial(v);
SUNMatDestroy(C); N_VDestroy(u); N_VDestroy(v); return(1);
}
else {
printf(" PASSED test -- SUNMatScaleAdd2 check 1 \n");
}
/* test 2: add A to a matrix with sufficient but misplaced storage */
D = SUNMatClone(A);
failure = SUNSparseMatrix_Reallocate(D, SM_NNZ_S(A)+SM_NNZ_S(B));
failure = SUNMatCopy(A, D); /* D = A */
if (failure) {
printf(">>> FAILED test -- SUNMatCopy returned %d \n",
failure);
SUNMatDestroy(C); SUNMatDestroy(D);
N_VDestroy(u); N_VDestroy(v); return(1);
}
failure = SUNMatScaleAdd(ONE, D, B); /* D = A+B */
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAdd returned %d \n",
failure);
SUNMatDestroy(C); SUNMatDestroy(D);
N_VDestroy(u); N_VDestroy(v); return(1);
}
failure = SUNMatMatvec(D, x, u); /* u = Cx = Ax+Bx */
if (failure) {
printf(">>> FAILED test -- SUNMatMatvec returned %d \n",
failure);
SUNMatDestroy(C); SUNMatDestroy(D);
N_VDestroy(u); N_VDestroy(v); return(1);
}
N_VLinearSum(ONE,y,ONE,z,v); /* v = y+z */
failure = check_vector(u, v, tol); /* u ?= v */
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAdd2 check 2 \n");
printf("\nA =\n");
SUNSparseMatrix_Print(A,stdout);
printf("\nB =\n");
SUNSparseMatrix_Print(B,stdout);
printf("\nD =\n");
SUNSparseMatrix_Print(D,stdout);
printf("\nx =\n");
N_VPrint_Serial(x);
printf("\ny =\n");
N_VPrint_Serial(y);
printf("\nz =\n");
N_VPrint_Serial(z);
printf("\nu =\n");
N_VPrint_Serial(u);
printf("\nv =\n");
N_VPrint_Serial(v);
SUNMatDestroy(C); SUNMatDestroy(D);
N_VDestroy(u); N_VDestroy(v); return(1);
}
else {
printf(" PASSED test -- SUNMatScaleAdd2 check 2 \n");
}
/* test 3: add A to a matrix with the appropriate structure already in place */
E = SUNMatClone(C);
failure = SUNMatCopy(C, E); /* E = A + B */
if (failure) {
printf(">>> FAILED test -- SUNMatCopy returned %d \n",
failure);
SUNMatDestroy(C); SUNMatDestroy(D); SUNMatDestroy(E);
N_VDestroy(u); N_VDestroy(v); return(1);
}
failure = SUNMatScaleAdd(NEG_ONE, E, B); /* E = -A */
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAdd returned %d \n",
failure);
SUNMatDestroy(C); SUNMatDestroy(D); SUNMatDestroy(E);
N_VDestroy(u); N_VDestroy(v); return(1);
}
failure = SUNMatMatvec(E, x, u); /* u = Ex = -Ax */
if (failure) {
printf(">>> FAILED test -- SUNMatMatvec returned %d \n",
failure);
SUNMatDestroy(C); SUNMatDestroy(D); SUNMatDestroy(E);
N_VDestroy(u); N_VDestroy(v); return(1);
}
N_VLinearSum(NEG_ONE,y,ZERO,z,v); /* v = -y */
failure = check_vector(u, v, tol); /* v ?= u */
if (failure) {
printf(">>> FAILED test -- SUNMatScaleAdd2 check 3 \n");
printf("\nA =\n");
SUNSparseMatrix_Print(A,stdout);
printf("\nB =\n");
SUNSparseMatrix_Print(B,stdout);
printf("\nC =\n");
SUNSparseMatrix_Print(C,stdout);
printf("\nE =\n");
SUNSparseMatrix_Print(E,stdout);
printf("\nx =\n");
N_VPrint_Serial(x);
printf("\ny =\n");
N_VPrint_Serial(y);
printf("\nu =\n");
N_VPrint_Serial(u);
printf("\nv =\n");
N_VPrint_Serial(v);
SUNMatDestroy(C); SUNMatDestroy(D); SUNMatDestroy(E);
N_VDestroy(u); N_VDestroy(v); return(1);
}
else {
printf(" PASSED test -- SUNMatScaleAdd2 check 3 \n");
}
SUNMatDestroy(C);
SUNMatDestroy(D);
SUNMatDestroy(E);
N_VDestroy(u);
N_VDestroy(v);
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);
}