static int KINBBDPrecSolve(N_Vector uu, N_Vector uscale,
N_Vector fval, N_Vector fscale,
N_Vector vv, void *bbd_data,
N_Vector vtemp)
{
KBBDPrecData pdata;
realtype *vd;
pdata = (KBBDPrecData) bbd_data;
/* do the backsolve and return */
vd = N_VGetArrayPointer(vv);
BandGBTRS(PP, lpivots, vd);
return(0);
}
static int IDABandSolve(IDAMem IDA_mem, N_Vector b, N_Vector weight,
N_Vector ycur, N_Vector ypcur, N_Vector rrcur)
{
IDADlsMem idadls_mem;
realtype *bd;
idadls_mem = (IDADlsMem) lmem;
bd = N_VGetArrayPointer(b);
BandGBTRS(JJ, pivots, bd);
/* Scale the correction to account for change in cj. */
if (cjratio != ONE) N_VScale(TWO/(ONE + cjratio), b, b);
last_flag = 0;
return(0);
}
static int CVBBDPrecSolve(realtype t, N_Vector y, N_Vector fy,
N_Vector r, N_Vector z,
realtype gamma, realtype delta,
int lr, void *bbd_data, N_Vector tmp)
{
CVBBDPrecData pdata;
realtype *zd;
pdata = (CVBBDPrecData) bbd_data;
/* Copy r to z, then do backsolve and return */
N_VScale(ONE, r, z);
zd = N_VGetArrayPointer(z);
BandGBTRS(savedP, pivots, zd);
return(0);
}
static int cpBBDPrecSolveImpl(realtype t, N_Vector y, N_Vector yp, N_Vector r,
N_Vector b, N_Vector x,
realtype gamma, realtype delta,
void *bbd_data, N_Vector tmp)
{
CPBBDPrecData pdata;
realtype *xd;
pdata = (CPBBDPrecData) bbd_data;
/* Copy b to x, do the backsolve, and return. */
N_VScale(ONE, b, x);
xd = N_VGetArrayPointer(x);
BandGBTRS(savedP, pivots, xd);
return(0);
}
static int cvBandSolve(CVodeMem cv_mem, N_Vector b, N_Vector weight,
N_Vector ycur, N_Vector fcur)
{
CVDlsMem cvdls_mem;
realtype *bd;
cvdls_mem = (CVDlsMem) lmem;
bd = N_VGetArrayPointer(b);
BandGBTRS(M, pivots, bd);
/* If CV_BDF, scale the correction to account for change in gamma */
if ((lmm == CV_BDF) && (gamrat != ONE)) {
N_VScale(TWO/(ONE + gamrat), b, b);
}
last_flag = CVDLS_SUCCESS;
return(0);
}
int IDABBDPrecSolve(realtype tt,
N_Vector yy, N_Vector yp, N_Vector rr,
N_Vector rvec, N_Vector zvec,
realtype c_j, realtype delta, void *prec_data,
N_Vector tmp)
{
IBBDPrecData pdata;
realtype *zd;
pdata = (IBBDPrecData) prec_data;
/* Copy rvec to zvec, do the backsolve, and return. */
N_VScale(ONE, rvec, zvec);
zd = N_VGetArrayPointer(zvec);
BandGBTRS(PP, pivots, zd);
return(0);
}
/*---------------------------------------------------------------
ARKBandPrecSolve:
ARKBandPrecSolve solves a linear system P z = r, where P is the
matrix computed by ARKBandPrecond.
The parameters of ARKBandPrecSolve used here are as follows:
r is the right-hand side vector of the linear system.
bp_data is a pointer to preconditoner data (set by ARKBandPrecInit)
z is the output vector computed by ARKBandPrecSolve.
The value returned by the ARKBandPrecSolve function is always 0,
indicating success.
---------------------------------------------------------------*/
static int ARKBandPrecSolve(realtype t, N_Vector y, N_Vector fy,
N_Vector r, N_Vector z,
realtype gamma, realtype delta,
int lr, void *bp_data, N_Vector tmp)
{
ARKBandPrecData pdata;
realtype *zd;
/* Assume matrix and lpivots have already been allocated. */
pdata = (ARKBandPrecData) bp_data;
/* Copy r to z. */
N_VScale(ONE, r, z);
/* Do band backsolve on the vector z. */
zd = N_VGetArrayPointer(z);
BandGBTRS(pdata->savedP, pdata->lpivots, zd);
return(0);
}
static int kinBandsolve(KINMem kin_mem, N_Vector x, N_Vector b, realtype *res_norm)
{
KINDlsMem kindls_mem;
realtype *xd;
kindls_mem = (KINDlsMem) lmem;
/* Copy the right-hand side into x */
N_VScale(ONE, b, x);
xd = N_VGetArrayPointer(x);
/* Back-solve and get solution in x */
BandGBTRS(J, lpivots, xd);
/* Compute the terms Jpnorm and sfdotJp for use in the global strategy
routines and in KINForcingTerm. Both of these terms are subsequently
corrected if the step is reduced by constraints or the line search.
sJpnorm is the norm of the scaled product (scaled by fscale) of
the current Jacobian matrix J and the step vector p.
sfdotJp is the dot product of the scaled f vector and the scaled
vector J*p, where the scaling uses fscale. */
sJpnorm = N_VWL2Norm(b,fscale);
N_VProd(b, fscale, b);
N_VProd(b, fscale, b);
sfdotJp = N_VDotProd(fval, b);
last_flag = KINDLS_SUCCESS;
return(0);
}
CAMLprim value c_bandmatrix_gbtrs(value va, value vp, value vb)
{
CAMLparam3(va, vp, vb);
BandGBTRS(DLSMAT(va), LONG_ARRAY(vp), REAL_ARRAY(vb));
CAMLreturn (Val_unit);
}
